def train_transform(resize, normalize=None):
if normalize == 'imagenet':
trans_fucn = [
albu.VerticalFlip(p=0.5),
albu.HorizontalFlip(p=0.5),
# albu.ToFloat(max_value=255, p=1.0),
albu.Normalize(p=1.0),
ToTensorV2(p=1.0)
]
elif normalize == 'global_norm':
trans_fucn = [
albu.VerticalFlip(p=0.5),
albu.HorizontalFlip(p=0.5),
GlobalNormalize(p=1.0),
# albu.ToFloat(max_value=255, p=1.0),
ToTensorV2(p=1.0)
]
else:
trans_fucn = [
albu.VerticalFlip(p=0.5),
albu.HorizontalFlip(p=0.5),
albu.Normalize(mean=(0, 0, 0), std=(1, 1, 1)),
# albu.ToFloat(max_value=255, p=1.0),
ToTensorV2(p=1.0)
]
return Compose(trans_fucn, p=1.0)
def get_transformv2(opt):
transform_list = []
# Transforms in opt.preprocess
if 'fixsize' in opt.preprocess:
transform_list.append(tr.Resize(286, 286, interpolation=2, p=1))
if 'resize' in opt.preprocess:
transform_list.append(
tr.Resize(opt.load_size, opt.load_size, interpolation=2, p=1))
if 'crop' in opt.preprocess:
transform_list.append(tr.RandomCrop(opt.crop_size, opt.crop_size, p=1))
# Transforms in colorspace
if 'color' in opt.preprocess:
transform_list.extend([
tr.RandomContrast(limit=0.2, p=0.5),
tr.RandomBrightness(limit=0.2, p=0.5),
tr.HueSaturationValue(hue_shift_limit=20,
sat_shift_limit=30,
val_shift_limit=20,
p=0.5),
# tr.ISONoise()
])
# Necessary transforms
transform_list.extend([
tr.HorizontalFlip(p=0.5),
tr.VerticalFlip(p=0.5),
tr.Normalize(p=1.0),
ToTensorV2(p=1)
])
return Compose(transform_list, additional_targets={'imageB': 'image'})
def common_aug(mode, params):
'''
:param mode: 'train', 'test', 'inference'
:param params:
'''
#aug_params = params.get('augm_params', dict())
augs_list = []
assert mode in {'train', 'debug', 'inference'}
if mode == 'train':
augs_list.append(albumentations.PadIfNeeded(min_height=params.data.net_hw[0], min_width=params.data.net_hw[1],
border_mode=cv2.BORDER_REPLICATE,
always_apply=True))
augs_list.append(albumentations.RandomCrop(height=params.data.net_hw[0], width=params.data.net_hw[1], always_apply=True))
if params.augmentation.rotate_limit:
augs_list.append(T.Rotate(limit=params.augmentation.rotate_limit, border_mode=cv2.BORDER_CONSTANT, always_apply=True))
# augs_list.append(T.OpticalDistortion(border_mode=cv2.BORDER_CONSTANT)) - can't handle boundboxes
elif mode == 'debug':
augs_list.append(albumentations.CenterCrop(height=params.data.net_hw[0], width=params.data.net_hw[1], always_apply=True))
if mode != 'inference':
if params.augmentation.get('blur_limit', 4):
augs_list.append(T.Blur(blur_limit=params.augmentation.get('blur_limit', 4)))
if params.augmentation.get('RandomBrightnessContrast', True):
augs_list.append(T.RandomBrightnessContrast())
#augs_list.append(T.MotionBlur())
if params.augmentation.get('JpegCompression', True):
augs_list.append(T.JpegCompression(quality_lower=30, quality_upper=100))
#augs_list.append(T.VerticalFlip())
if params.augmentation.get('HorizontalFlip', True):
augs_list.append(T.HorizontalFlip())
return albumentations.ReplayCompose(augs_list, p=1., bbox_params = {'format':'albumentations', 'min_visibility':0.5})
def AlbumentationTrainTransform(self):
tf = tc.Compose([
ta.HorizontalFlip(),
ta.Cutout(num_holes=1, max_h_size=16, max_w_size=16),
tp.ToTensor(dict(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)))
])
return lambda img: tf(image=np.array(img))["image"]
def __init__(self,
root,
input_transform=None,
target_transform=None,
_train=False):
self.images_root = os.path.join(root, 'Images')
self.labels_root = os.path.join(root, 'Labels')
self._train = _train
self.filenames = [
image_basename(f) for f in os.listdir(self.labels_root)
if is_image(f)
]
random.shuffle(self.filenames)
self.input_transform = input_transform
self.target_transform = target_transform
self.A_transform = A.Compose([
A.Rotate(limit=40, p=0.9),
A.HorizontalFlip(p=0.5),
A.RGBShift(r_shift_limit=25,
g_shift_limit=25,
b_shift_limit=25,
p=0.9),
A.OneOf([A.Blur(blur_limit=2, p=0.5),
A.ColorJitter(p=0.5)], p=1.0)
])
def AlbumentationTrainTransform(self):
tf = tc.Compose([ta.PadIfNeeded(4, 4, always_apply=True),
ta.RandomCrop(height=32, width=32, always_apply=True),
ta.Cutout(num_holes = 1, max_h_size=8, max_w_size=8, always_apply=True),
ta.HorizontalFlip(),
tp.ToTensor(dict (mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)))
])
return lambda img: tf(image = np.array(img))["image"]
def model10_resnet_train_transforms():
transforms = C.Compose([
A.HorizontalFlip(),
#A.RandomCrop(height=30, width=30, p=5.0),
A.Cutout(num_holes=1, max_h_size=16, max_w_size=16),
P.ToTensor(dict (mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)))
])
return lambda img: transforms(image = np.array(img))["image"]
def flip_augment(image, mask):
'''
flip an image vertically or horizontally.
Args:
image(nd.array)
mask(nd.array)
Returns:
(flip_image, flip_mask) (tuple) : tuple of flipped image and mask.
'''
if (random.randint(0, 1) == 0):
flip_img = transforms.HorizontalFlip().apply(image)
flip_mask = transforms.HorizontalFlip().apply_to_mask(mask)
else:
flip_img = transforms.VerticalFlip().apply(image)
flip_mask = transforms.VerticalFlip().apply_to_mask(mask)
return (flip_img, flip_mask)
def model12_train_transforms():
transform = C.Compose([
A.PadIfNeeded(min_height=70, min_width=70, border_mode=cv2.BORDER_CONSTANT,
value=0.5),
A.RandomCrop(height=64, width=64),
A.HorizontalFlip(p=0.5),
A.Cutout(num_holes=1, max_h_size=32, max_w_size=32, p=1),
P.ToTensor(dict (mean=(0.4802, 0.4481, 0.3975), std=(0.2302, 0.2265, 0.2262)))
])
return lambda img: transform(image = np.array(img))["image"]
def model11_davidnet_train_transforms():
transform = C.Compose([
A.PadIfNeeded(min_height=36, min_width=36, border_mode=cv2.BORDER_CONSTANT,
value=0.5),
A.RandomCrop(height=32, width=32, p=1),
A.HorizontalFlip(p=0.5),
A.Cutout(num_holes=1, max_h_size=8, max_w_size=8, p=1),
P.ToTensor(dict (mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5)))
])
return lambda img: transform(image = np.array(img))["image"]
def AlbumentationTrainTransform(self):
tf = tc.Compose([ta.HorizontalFlip(p=0.5),
ta.Rotate(limit=(-20, 20)),
# ta.VerticalFlip(p=0.5),
# ta.Cutout(num_holes=3, max_h_size=8, max_w_size=8, p=0.5),
# ta.Blur(),
# ta.ChannelShuffle(),
# ta.InvertImg(),
ta.RandomCrop(height=30, width=30, p=5.0),
ta.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
tp.ToTensor()
])
return lambda img: tf(image = np.array(img))["image"]
def ben_augmentation():
# !! Need to do something to change color _probably_
return ACompose([
atransforms.HorizontalFlip(p=0.5),
atransforms.RandomRotate90(p=1.0),
atransforms.ShiftScaleRotate(shift_limit=0, scale_limit=0, p=1.0),
atransforms.RandomSizedCrop((60, 120),
height=128,
width=128,
interpolation=3),
# atransforms.GridDistortion(num_steps=5, p=0.5), # !! Maybe too much noise?
atransforms.Normalize(mean=BEN_BAND_STATS['mean'],
std=BEN_BAND_STATS['std']),
# atransforms.ChannelDropout(channel_drop_range=(1, 2), p=0.5),
AToTensor(),
])
def get_augmentations():
"""Get a list of 'major' and 'minor' augmentation functions for the pipeline in a dictionary."""
return {
"major": {
"shift-scale-rot":
trans.ShiftScaleRotate(
shift_limit=0.05,
rotate_limit=35,
border_mode=cv2.BORDER_REPLICATE,
always_apply=True,
),
"crop":
trans.RandomResizedCrop(100,
100,
scale=(0.8, 0.95),
ratio=(0.8, 1.2),
always_apply=True),
# "elastic": trans.ElasticTransform(
# alpha=0.8,
# alpha_affine=10,
# sigma=40,
# border_mode=cv2.BORDER_REPLICATE,
# always_apply=True,
# ),
"distort":
trans.OpticalDistortion(0.2, always_apply=True),
},
"minor": {
"blur":
trans.GaussianBlur(7, always_apply=True),
"noise":
trans.GaussNoise((20.0, 40.0), always_apply=True),
"bright-contrast":
trans.RandomBrightnessContrast(0.4, 0.4, always_apply=True),
"hsv":
trans.HueSaturationValue(30, 40, 50, always_apply=True),
"rgb":
trans.RGBShift(always_apply=True),
"flip":
trans.HorizontalFlip(always_apply=True),
},
}
def augmentation(in_path='./train/raw_images/',
out_path='./train/aug_images/'):
for filename in os.listdir(in_path):
hf = transforms.HorizontalFlip(always_apply=True)
vf = transforms.VerticalFlip(always_apply=True)
tp = transforms.Transpose(always_apply=True)
rt = transforms.Rotate(limit=80, always_apply=True)
image = np.array(Image.open(in_path + filename))
hf_image = hf(image=image)['image']
vf_image = vf(image=image)['image']
tp_image = tp(image=image)['image']
rt_image = rt(image=image)['image']
count = 1
for img in [image, hf_image, vf_image, tp_image, rt_image]:
if len(img.shape) == 2:
img = Image.fromarray(img)
img.convert(mode='RGB')
else:
img = Image.fromarray(img, mode='RGB')
img.save(out_path +
filename.replace('.jpg', '_' + str(count) + '.jpg'))
count += 1
def create_transform(self, args, is_train):
"""
Convert numpy array into Tensor if dataset is for validation.
Apply data augmentation method to train dataset while cv or test if args.use_aug is 1.
is_train: boolean
flg that dataset is for validation in cv or test
return: Compose of albumentations
"""
if is_train and args.use_aug == 1:
transform = A.Compose([
trans.Normalize(mean=self.cifar_10_mean,
std=self.cifar_10_std,
max_pixel_value=1.0),
trans.HorizontalFlip(p=0.5),
trans.ShiftScaleRotate(shift_limit=0,
scale_limit=0.25,
rotate_limit=30,
p=1),
trans.CoarseDropout(max_holes=1,
min_holes=1,
min_width=12,
min_height=12,
max_height=12,
max_width=12,
p=0.5),
ToTensorV2()
])
else:
transform = A.Compose([
trans.Normalize(mean=self.cifar_10_mean,
std=self.cifar_10_std,
max_pixel_value=1.0),
ToTensorV2()
])
return transform
def __init__(self, im_paths=None, labels=None, phase=None, resize=False):
"""
Args:
im_paths (numpy): image_data
y (numpy): label data
transform: pytorch transforms for transforms and tensor conversion
"""
self.im_paths = im_paths
self.labels = labels
self.resize = resize
self.albumentations_transform = {
'train':
Compose([
ab_transforms.HorizontalFlip(p=0.2),
ab_transforms.VerticalFlip(p=0.2),
ab_transforms.Rotate(limit=180, p=0.2),
ab_transforms.HueSaturationValue(p=0.1),
ab_transforms.RandomContrast(p=0.1),
ab_transforms.GaussianBlur(blur_limit=3, p=0.2),
ab_transforms.GaussNoise(p=0.05),
ab_transforms.CLAHE(p=0.2),
ab_transforms.Normalize(mean=[0.5944, 0.4343, 0.5652],
std=[0.2593, 0.2293, 0.2377]),
ToTensor()
]),
'val':
Compose([
ab_transforms.Normalize(mean=[0.5944, 0.4343, 0.5652],
std=[0.2593, 0.2293, 0.2377]),
ToTensor()
]),
}
if phase == 'train':
self.transform = self.albumentations_transform['train']
else:
self.transform = self.albumentations_transform['val']
def main():
args = parse_args()
if args.name is None:
args.name = '%s_%s' % (args.arch, datetime.now().strftime('%m%d%H'))
if not os.path.exists('models/%s' % args.name):
os.makedirs('models/%s' % args.name)
if args.resume:
args = joblib.load('models/%s/args.pkl' % args.name)
args.resume = True
print('Config -----')
for arg in vars(args):
print('- %s: %s' % (arg, getattr(args, arg)))
print('------------')
with open('models/%s/args.txt' % args.name, 'w') as f:
for arg in vars(args):
print('- %s: %s' % (arg, getattr(args, arg)), file=f)
joblib.dump(args, 'models/%s/args.pkl' % args.name)
if args.seed is not None and not args.resume:
print('set random seed')
random.seed(args.seed)
np.random.seed(args.seed)
torch.manual_seed(args.seed)
if args.loss == 'BCEWithLogitsLoss':
criterion = BCEWithLogitsLoss().cuda()
elif args.loss == 'WeightedBCEWithLogitsLoss':
criterion = BCEWithLogitsLoss(weight=torch.Tensor([1., 1., 1., 1., 1., 2.]),
smooth=args.label_smooth).cuda()
elif args.loss == 'FocalLoss':
criterion = FocalLoss().cuda()
elif args.loss == 'WeightedFocalLoss':
criterion = FocalLoss(weight=torch.Tensor([1., 1., 1., 1., 1., 2.])).cuda()
else:
raise NotImplementedError
if args.pred_type == 'all':
num_outputs = 6
elif args.pred_type == 'except_any':
num_outputs = 5
else:
raise NotImplementedError
cudnn.benchmark = True
# create model
model = get_model(model_name=args.arch,
num_outputs=num_outputs,
freeze_bn=args.freeze_bn,
dropout_p=args.dropout_p,
pooling=args.pooling,
lp_p=args.lp_p)
model = model.cuda()
train_transform = Compose([
transforms.Resize(args.img_size, args.img_size),
transforms.HorizontalFlip() if args.hflip else NoOp(),
transforms.VerticalFlip() if args.vflip else NoOp(),
transforms.ShiftScaleRotate(
shift_limit=args.shift_limit,
scale_limit=args.scale_limit,
rotate_limit=args.rotate_limit,
border_mode=cv2.BORDER_CONSTANT,
value=0,
p=args.shift_scale_rotate_p
) if args.shift_scale_rotate else NoOp(),
transforms.RandomContrast(
limit=args.contrast_limit,
p=args.contrast_p
) if args.contrast else NoOp(),
RandomErase() if args.random_erase else NoOp(),
transforms.CenterCrop(args.crop_size, args.crop_size) if args.center_crop else NoOp(),
ForegroundCenterCrop(args.crop_size) if args.foreground_center_crop else NoOp(),
transforms.RandomCrop(args.crop_size, args.crop_size) if args.random_crop else NoOp(),
transforms.Normalize(mean=model.mean, std=model.std),
ToTensor(),
])
if args.img_type:
stage_1_train_dir = 'processed/stage_1_train_%s' %args.img_type
else:
stage_1_train_dir = 'processed/stage_1_train'
df = pd.read_csv('inputs/stage_1_train.csv')
img_paths = np.array([stage_1_train_dir + '/' + '_'.join(s.split('_')[:-1]) + '.png' for s in df['ID']][::6])
labels = np.array([df.loc[c::6, 'Label'].values for c in range(6)]).T.astype('float32')
df = df[::6]
df['img_path'] = img_paths
for c in range(6):
df['label_%d' %c] = labels[:, c]
df['ID'] = df['ID'].apply(lambda s: '_'.join(s.split('_')[:-1]))
meta_df = pd.read_csv('processed/stage_1_train_meta.csv')
meta_df['ID'] = meta_df['SOPInstanceUID']
test_meta_df = pd.read_csv('processed/stage_1_test_meta.csv')
df = pd.merge(df, meta_df, how='left')
patient_ids = meta_df['PatientID'].unique()
test_patient_ids = test_meta_df['PatientID'].unique()
if args.remove_test_patient_ids:
patient_ids = np.array([s for s in patient_ids if not s in test_patient_ids])
train_img_paths = np.hstack(df[['img_path', 'PatientID']].groupby(['PatientID'])['img_path'].apply(np.array).loc[patient_ids].to_list()).astype('str')
train_labels = []
for c in range(6):
train_labels.append(np.hstack(df[['label_%d' %c, 'PatientID']].groupby(['PatientID'])['label_%d' %c].apply(np.array).loc[patient_ids].to_list()))
train_labels = np.array(train_labels).T
if args.resume:
checkpoint = torch.load('models/%s/checkpoint.pth.tar' % args.name)
# train
train_set = Dataset(
train_img_paths,
train_labels,
transform=train_transform)
train_loader = torch.utils.data.DataLoader(
train_set,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.num_workers,
# pin_memory=True,
)
if args.optimizer == 'Adam':
optimizer = optim.Adam(
filter(lambda p: p.requires_grad, model.parameters()), lr=args.lr, weight_decay=args.weight_decay)
elif args.optimizer == 'AdamW':
optimizer = optim.AdamW(
filter(lambda p: p.requires_grad, model.parameters()), lr=args.lr, weight_decay=args.weight_decay)
elif args.optimizer == 'RAdam':
optimizer = RAdam(
filter(lambda p: p.requires_grad, model.parameters()), lr=args.lr, weight_decay=args.weight_decay)
elif args.optimizer == 'SGD':
optimizer = optim.SGD(filter(lambda p: p.requires_grad, model.parameters()), lr=args.lr,
momentum=args.momentum, weight_decay=args.weight_decay, nesterov=args.nesterov)
else:
raise NotImplementedError
if args.apex:
amp.initialize(model, optimizer, opt_level='O1')
if args.scheduler == 'CosineAnnealingLR':
scheduler = lr_scheduler.CosineAnnealingLR(
optimizer, T_max=args.epochs, eta_min=args.min_lr)
elif args.scheduler == 'MultiStepLR':
scheduler = lr_scheduler.MultiStepLR(optimizer,
milestones=[int(e) for e in args.milestones.split(',')], gamma=args.gamma)
else:
raise NotImplementedError
log = {
'epoch': [],
'loss': [],
}
start_epoch = 0
if args.resume:
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
scheduler.load_state_dict(checkpoint['scheduler'])
start_epoch = checkpoint['epoch']
log = pd.read_csv('models/%s/log.csv' % args.name).to_dict(orient='list')
for epoch in range(start_epoch, args.epochs):
print('Epoch [%d/%d]' % (epoch + 1, args.epochs))
# train for one epoch
train_loss = train(args, train_loader, model, criterion, optimizer, epoch)
if args.scheduler == 'CosineAnnealingLR':
scheduler.step()
print('loss %.4f' % (train_loss))
log['epoch'].append(epoch)
log['loss'].append(train_loss)
pd.DataFrame(log).to_csv('models/%s/log.csv' % args.name, index=False)
torch.save(model.state_dict(), 'models/%s/model.pth' % args.name)
print("=> saved model")
state = {
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict(),
'scheduler': scheduler.state_dict(),
}
torch.save(state, 'models/%s/checkpoint.pth.tar' % args.name)
pmda_train_transform = transforms.Compose([
transforms.RandomCrop(32, padding=4, padding_mode='reflect'),
transforms.RandomHorizontalFlip(),
transforms.CenterCrop(32),
transforms.ToTensor(),
transforms.Normalize(*stats)
])
train_transform = A.Compose([ # cutout, HorizontalFlip
albtransforms.RandomCrop(28, 28, always_apply=False, p=1.0),
albtransforms.Rotate(30, p=0.1),
albtransforms.Cutout(num_holes=8,
max_h_size=8,
max_w_size=8,
always_apply=False,
p=0.1),
albtransforms.HorizontalFlip(1.0),
A.Normalize(*stats),
ToTensor()
])
test_transform = A.Compose([A.Normalize(*stats), ToTensor()])
# loaded only when loaddata() invoked
trainset = None
trainloader = None
testset = None
testloader = None
def __custom_getitem__(self, index):
image, label = self.data[index], self.targets[index]
import torch
from torchvision import transforms, utils
import albumentations as alb
import albumentations.augmentations.transforms as aat
class AlbuWrapperNumpy: # typing: ignore
def __init__(self, atrans: alb.BasicTransform):
self.atrans = atrans
def __call__(self, img):
return self.atrans(image=img)["image"]
alb_transforms = alb.Compose(
[
alb.Resize(256, 256, always_apply=True),
alb.RandomCrop(244, 244, always_apply=True),
aat.HorizontalFlip(),
aat.Cutout(2, 10, 10)
])
alb_rescale = alb.Resize(244, 244, always_apply=True)
transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize(0.449, 0.226)])
test_transforms = transforms.Compose(
[AlbuWrapperNumpy(alb_rescale), transform])
train_transforms = transforms.Compose(
[AlbuWrapperNumpy(alb_transforms), transform])
def augment(im, params=None):
"""
Perform data augmentation on some image using the albumentations package.
Parameters
----------
im : Numpy array
params : dict or None
Contains the data augmentation parameters
Mandatory keys:
- h_flip ([0,1] float): probability of performing an horizontal left-right mirroring.
- v_flip ([0,1] float): probability of performing an vertical up-down mirroring.
- rot ([0,1] float): probability of performing a rotation to the image.
- rot_lim (int): max degrees of rotation.
- stretch ([0,1] float): probability of randomly stretching an image.
- crop ([0,1] float): randomly take an image crop.
- zoom ([0,1] float): random zoom applied to crop_size.
--> Therefore the effective crop size at each iteration will be a
random number between 1 and crop*(1-zoom). For example:
* crop=1, zoom=0: no crop of the image
* crop=1, zoom=0.1: random crop of random size between 100% image and 90% of the image
* crop=0.9, zoom=0.1: random crop of random size between 90% image and 80% of the image
* crop=0.9, zoom=0: random crop of always 90% of the image
Image size refers to the size of the shortest side.
- blur ([0,1] float): probability of randomly blurring an image.
- pixel_noise ([0,1] float): probability of randomly adding pixel noise to an image.
- pixel_sat ([0,1] float): probability of randomly using HueSaturationValue in the image.
- cutout ([0,1] float): probability of using cutout in the image.
Returns
-------
Numpy array
"""
## 1) Crop the image
effective_zoom = np.random.rand() * params['zoom']
crop = params['crop'] - effective_zoom
ly, lx, channels = im.shape
crop_size = int(crop * min([ly, lx]))
rand_x = np.random.randint(low=0, high=lx - crop_size + 1)
rand_y = np.random.randint(low=0, high=ly - crop_size + 1)
crop = transforms.Crop(x_min=rand_x,
y_min=rand_y,
x_max=rand_x + crop_size,
y_max=rand_y + crop_size)
im = crop(image=im)['image']
## 2) Now add the transformations for augmenting the image pixels
transform_list = []
# Add random stretching
if params['stretch']:
transform_list.append(
imgaug_transforms.IAAPerspective(scale=0.1, p=params['stretch']))
# Add random rotation
if params['rot']:
transform_list.append(
transforms.Rotate(limit=params['rot_lim'], p=params['rot']))
# Add horizontal flip
if params['h_flip']:
transform_list.append(transforms.HorizontalFlip(p=params['h_flip']))
# Add vertical flip
if params['v_flip']:
transform_list.append(transforms.VerticalFlip(p=params['v_flip']))
# Add some blur to the image
if params['blur']:
transform_list.append(
albumentations.OneOf([
transforms.MotionBlur(blur_limit=7, p=1.),
transforms.MedianBlur(blur_limit=7, p=1.),
transforms.Blur(blur_limit=7, p=1.),
],
p=params['blur']))
# Add pixel noise
if params['pixel_noise']:
transform_list.append(
albumentations.OneOf(
[
transforms.CLAHE(clip_limit=2, p=1.),
imgaug_transforms.IAASharpen(p=1.),
imgaug_transforms.IAAEmboss(p=1.),
transforms.RandomBrightnessContrast(contrast_limit=0,
p=1.),
transforms.RandomBrightnessContrast(brightness_limit=0,
p=1.),
transforms.RGBShift(p=1.),
transforms.RandomGamma(p=1.) #,
# transforms.JpegCompression(),
# transforms.ChannelShuffle(),
# transforms.ToGray()
],
p=params['pixel_noise']))
# Add pixel saturation
if params['pixel_sat']:
transform_list.append(
transforms.HueSaturationValue(p=params['pixel_sat']))
# Remove randomly remove some regions from the image
if params['cutout']:
ly, lx, channels = im.shape
scale_low, scale_high = 0.05, 0.25 # min and max size of the squares wrt the full image
scale = np.random.uniform(scale_low, scale_high)
transform_list.append(
transforms.Cutout(num_holes=8,
max_h_size=int(scale * ly),
max_w_size=int(scale * lx),
p=params['cutout']))
# Compose all image transformations and augment the image
augmentation_fn = albumentations.Compose(transform_list)
im = augmentation_fn(image=im)['image']
return im
transforms.RandomHorizontalFlip(),
transforms.CenterCrop(32),
transforms.ToTensor(),
transforms.Normalize(*stats)
])
train_transform = A.Compose([
albtransforms.PadIfNeeded(min_height=40,
min_width=40,
border_mode=4,
value=[0, 0, 0],
always_apply=False,
p=1.),
#albtransforms.RandomCrop(32,32,always_apply=False, p=1.0),
albtransforms.RandomCrop(32, 32, always_apply=False, p=1.),
#albtransforms.HorizontalFlip(1.0),
albtransforms.HorizontalFlip(0.5),
albtransforms.Cutout(num_holes=8,
max_h_size=8,
max_w_size=8,
always_apply=False,
p=0.1),
A.Normalize(*stats),
ToTensor()
])
test_transform = A.Compose([A.Normalize(*stats), ToTensor()])
# loaded only when loaddata() invoked
trainset = None
trainloader = None
testset = None
def augment(im, params=None):
"""
Perform data augmentation on some image using the albumentations package.
Parameters
----------
im : Numpy array
params : dict or None
Contains the data augmentation parameters
Mandatory keys:
- h_flip ([0,1] float): probability of performing an horizontal left-right mirroring.
- v_flip ([0,1] float): probability of performing an vertical up-down mirroring.
- rot ([0,1] float): probability of performing a rotation to the image.
- rot_lim (int): max degrees of rotation.
- stretch ([0,1] float): probability of randomly stretching an image.
- expand ([True, False] bool): whether to pad the image to a square shape with background color canvas.
- crop ([0,1] float): randomly take an image crop.
- invert_col ([0, 1] float): randomly invert the colors of the image. p=1 -> invert colors (VPR)
- zoom ([0,1] float): random zoom applied to crop_size.
--> Therefore the effective crop size at each iteration will be a
random number between 1 and crop*(1-zoom). For example:
* crop=1, zoom=0: no crop of the image
* crop=1, zoom=0.1: random crop of random size between 100% image and 90% of the image
* crop=0.9, zoom=0.1: random crop of random size between 90% image and 80% of the image
* crop=0.9, zoom=0: random crop of always 90% of the image
Image size refers to the size of the shortest side.
- blur ([0,1] float): probability of randomly blurring an image.
- pixel_noise ([0,1] float): probability of randomly adding pixel noise to an image.
- pixel_sat ([0,1] float): probability of randomly using HueSaturationValue in the image.
- cutout ([0,1] float): probability of using cutout in the image.
Returns
-------
Numpy array
"""
## 1) Expand the image by padding it with bg-color canvas
if params["expand"]:
desired_size = max(im.shape)
# check bg
if np.argmax(im.shape) > 0:
bgcol = tuple(np.repeat(int(np.mean(im[[0, -1], :, :])), 3))
else:
bgcol = tuple(np.repeat(int(np.mean(im[:, [0, -1], :])), 3))
im = Image.fromarray(im)
old_size = im.size # old_size[0] is in (width, height) format
ratio = float(desired_size) / max(old_size)
new_size = tuple([int(x * ratio) for x in old_size])
im = im.resize(new_size, Image.ANTIALIAS)
# create a new image and paste the resized on it
new_im = Image.new("RGB", (desired_size, desired_size), color=bgcol)
new_im.paste(im, ((desired_size - new_size[0]) // 2,
(desired_size - new_size[1]) // 2))
im = np.array(new_im)
## 2) Crop the image
if params["crop"] and params["crop"] != 1:
effective_zoom = np.random.rand() * params['zoom']
crop = params['crop'] - effective_zoom
ly, lx, channels = im.shape
crop_size = int(crop * min([ly, lx]))
rand_x = np.random.randint(low=0, high=lx - crop_size + 1)
rand_y = np.random.randint(low=0, high=ly - crop_size + 1)
crop = transforms.Crop(x_min=rand_x,
y_min=rand_y,
x_max=rand_x + crop_size,
y_max=rand_y + crop_size)
im = crop(image=im)['image']
if params["enhance"]:
im = Image.fromarray(im)
enhancer = ImageEnhance.Contrast(im)
im = np.array(enhancer.enhance(params["enhance"]))
## 3) Now add the transformations for augmenting the image pixels
transform_list = []
if params['invert_col']:
transform_list.append(transforms.InvertImg(p=params['invert_col']))
# Add random stretching
if params['stretch']:
transform_list.append(
imgaug_transforms.IAAPerspective(scale=0.1, p=params['stretch']))
# Add random rotation
if params['rot']:
transform_list.append(
transforms.Rotate(limit=params['rot_lim'], p=params['rot']))
# Add horizontal flip
if params['h_flip']:
transform_list.append(transforms.HorizontalFlip(p=params['h_flip']))
# Add vertical flip
if params['v_flip']:
transform_list.append(transforms.VerticalFlip(p=params['v_flip']))
# Add some blur to the image
if params['blur']:
transform_list.append(
albumentations.OneOf([
transforms.MotionBlur(blur_limit=7, p=1.),
transforms.MedianBlur(blur_limit=7, p=1.),
transforms.Blur(blur_limit=7, p=1.),
],
p=params['blur']))
# Add pixel noise
if params['pixel_noise']:
transform_list.append(
albumentations.OneOf(
[
transforms.CLAHE(clip_limit=2, p=1.),
imgaug_transforms.IAASharpen(p=1.),
imgaug_transforms.IAAEmboss(p=1.),
transforms.RandomBrightnessContrast(contrast_limit=0,
p=1.),
transforms.RandomBrightnessContrast(brightness_limit=0,
p=1.),
transforms.RGBShift(p=1.),
transforms.RandomGamma(p=1.) #,
# transforms.JpegCompression(),
# transforms.ChannelShuffle(),
# transforms.ToGray()
],
p=params['pixel_noise']))
# Add pixel saturation
if params['pixel_sat']:
transform_list.append(
transforms.HueSaturationValue(p=params['pixel_sat']))
# Remove randomly remove some regions from the image
if params['cutout']:
ly, lx, channels = im.shape
scale_low, scale_high = 0.05, 0.25 # min and max size of the squares wrt the full image
scale = np.random.uniform(scale_low, scale_high)
transform_list.append(
transforms.Cutout(num_holes=8,
max_h_size=int(scale * ly),
max_w_size=int(scale * lx),
p=params['cutout']))
# Compose all image transformations and augment the image
augmentation_fn = albumentations.Compose(transform_list)
im = augmentation_fn(image=im)['image']
return im
from dataset import TRAFFIC_LABELS_TO_NUM
alb_transforms = [
alb.IAAAdditiveGaussianNoise(p=1),
alb.GaussNoise(p=1),
alb.MotionBlur(p=1),
alb.MedianBlur(blur_limit=3, p=1),
alb.Blur(blur_limit=3, p=1),
alb.OpticalDistortion(p=1),
alb.GridDistortion(p=1),
alb.IAAPiecewiseAffine(p=1),
aat.CLAHE(clip_limit=2, p=1),
alb.IAASharpen(p=1),
alb.IAAEmboss(p=1),
aat.HueSaturationValue(p=0.3),
aat.HorizontalFlip(p=1),
aat.RGBShift(),
aat.RandomBrightnessContrast(),
aat.RandomGamma(p=1),
aat.Cutout(2, 10, 10, p=1),
aat.Equalize(mode='cv', p=1),
aat.FancyPCA(p=1),
aat.RandomFog(p=1),
aat.RandomRain(blur_value=3, p=1),
albumentations.IAAAffine(p=1),
albumentations.ShiftScaleRotate(rotate_limit=15, p=1)
]
def one_by_one():
data_dir = 'train_val/pic'
def HorizontalFlip(p=0.5):
return transforms.HorizontalFlip(p=p)
def seed_everything(seed):
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic = True
seed_everything(config.SEED)
# In[58]:
traindf, valdf = prepare_data(config.SEED, n_samples=5000)
augmentation = Compose([A.HorizontalFlip(p=0.5)])
traindataset = Lepton(traindf, augmentation, mode='train')
valdataset = Lepton(valdf, None, mode='validation')
# Iterator to make batches
trainloader = DataLoader(traindataset,
batch_size=config.BATCH_SIZE,
sampler=RandomSampler(traindataset))
valloader = DataLoader(valdataset,
batch_size=config.BATCH_SIZE,
sampler=SequentialSampler(valdataset))
# Initialise Model
model = PaperCNN()
