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 __init__(
self,
prob=0.7,
blur_prob=0.7,
jitter_prob=0.7,
rotate_prob=0.7,
flip_prob=0.7,
):
super().__init__()
self.prob = prob
self.blur_prob = blur_prob
self.jitter_prob = jitter_prob
self.rotate_prob = rotate_prob
self.flip_prob = flip_prob
self.transforms = al.Compose(
[
transforms.RandomRotate90(),
transforms.Flip(),
transforms.HueSaturationValue(),
transforms.RandomBrightnessContrast(),
transforms.Transpose(),
OneOf([
transforms.RandomCrop(220, 220, p=0.5),
transforms.CenterCrop(220, 220, p=0.5)
],
p=0.5),
# transforms.Resize(352,352),
# transforms.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),
],
p=self.prob)
def augmentation(mode, target_size, prob=0.5, aug_m=2):
'''
description: augmentation
mode: 'train' 'test'
target_size: int or list, the shape of image ,
aug_m: Strength of transform
'''
high_p = prob
low_p = high_p / 2.0
M = aug_m
first_size = [int(x / 0.7) for x in target_size]
if mode == 'train':
return composition.Compose([
transforms.Resize(first_size[0], first_size[1], interpolation=3),
transforms.Flip(p=0.5),
composition.OneOf([
RandomCenterCut(scale=0.1 * M),
transforms.ShiftScaleRotate(shift_limit=0.05 * M,
scale_limit=0.1 * M,
rotate_limit=180,
border_mode=cv2.BORDER_CONSTANT,
value=0),
albumentations.imgaug.transforms.IAAAffine(
shear=(-10 * M, 10 * M), mode='constant')
],
p=high_p),
transforms.RandomBrightnessContrast(
brightness_limit=0.1 * M, contrast_limit=0.03 * M, p=high_p),
transforms.HueSaturationValue(hue_shift_limit=5 * M,
sat_shift_limit=15 * M,
val_shift_limit=10 * M,
p=high_p),
transforms.OpticalDistortion(distort_limit=0.03 * M,
shift_limit=0,
border_mode=cv2.BORDER_CONSTANT,
value=0,
p=low_p),
composition.OneOf([
transforms.Blur(blur_limit=7),
albumentations.imgaug.transforms.IAASharpen(),
transforms.GaussNoise(var_limit=(2.0, 10.0), mean=0),
transforms.ISONoise()
],
p=low_p),
transforms.Resize(target_size[0], target_size[1], interpolation=3),
transforms.Normalize(mean=(0.5, 0.5, 0.5),
std=(0.5, 0.5, 0.5),
max_pixel_value=255.0)
],
p=1)
else:
return composition.Compose([
transforms.Resize(target_size[0], target_size[1], interpolation=3),
transforms.Normalize(mean=(0.5, 0.5, 0.5),
std=(0.5, 0.5, 0.5),
max_pixel_value=255.0)
],
p=1)
def HueSaturationValue(hue_shift_limit=10,
sat_shift_limit=30,
val_shift_limit=20,
p=0.5):
return transforms.HueSaturationValue(hue_shift_limit=hue_shift_limit,
sat_shift_limit=sat_shift_limit,
val_shift_limit=val_shift_limit,
p=p)
def get_presize_combine_transforms_V4():
transforms_presize = A.Compose([
transforms.PadIfNeeded(600, 800),
geometric.Perspective(
scale=[0, .1],
pad_mode=cv2.BORDER_REFLECT,
interpolation=cv2.INTER_AREA, p = .3),
transforms.Flip(),
geometric.ShiftScaleRotate(interpolation=cv2.INTER_LANCZOS4, p = 0.95, scale_limit=0.0),
crops.RandomResizedCrop(
TARGET_SIZE, TARGET_SIZE,
scale=(config['rrc_scale_min'], config['rrc_scale_max']),
ratio=(.70, 1.4),
interpolation=cv2.INTER_CUBIC,
p=1.0),
transforms.Transpose()
#rotate.Rotate(interpolation=cv2.INTER_LANCZOS4, p = 0.99),
])
transforms_postsize = A.Compose([
#imgaug.IAAPiecewiseAffine(),
transforms.CoarseDropout(),
transforms.CLAHE(p=.1),
transforms.RandomToneCurve(scale=.1, p=0.2),
transforms.RandomBrightnessContrast(
brightness_limit=.1,
contrast_limit=0.4,
p=.8),
transforms.HueSaturationValue(
hue_shift_limit=20,
sat_shift_limit=50,
val_shift_limit=0,
p=0.5),
transforms.Equalize(p=0.05),
transforms.FancyPCA(p=0.05),
transforms.RandomGridShuffle(p=0.1),
A.OneOf([
transforms.MotionBlur(blur_limit=(3, 9)),
transforms.GaussianBlur(),
transforms.MedianBlur()
], p=0.1),
transforms.ISONoise(p=.2),
transforms.GaussNoise(var_limit=127., p=.3),
A.OneOf([
transforms.GridDistortion(interpolation=cv2.INTER_AREA, distort_limit=[0.7, 0.7], p=0.5),
transforms.OpticalDistortion(interpolation=cv2.INTER_AREA, p=.3),
], p=.3),
geometric.ElasticTransform(alpha=4, sigma=4, alpha_affine=4, interpolation=cv2.INTER_AREA, p=0.3),
transforms.CoarseDropout(),
transforms.Normalize(),
ToTensorV2()
])
return transforms_presize, transforms_postsize
def get_presize_combine_tune_transforms():
transforms_presize = A.Compose([
transforms.Transpose(),
transforms.Flip(),
#transforms.PadIfNeeded(600, 800),
crops.RandomResizedCrop(
TARGET_SIZE, TARGET_SIZE,
scale=(.75, 1),
interpolation=cv2.INTER_CUBIC,
p=1.0),
rotate.Rotate(interpolation=cv2.INTER_LANCZOS4, p = 0.99),
])
transforms_postsize = A.Compose([
transforms.CoarseDropout(),
# transforms.CLAHE(p=.1),
transforms.RandomToneCurve(scale=.1),
transforms.RandomBrightnessContrast(
brightness_limit=.1,
contrast_limit=0.2,
p=.7),
transforms.HueSaturationValue(
hue_shift_limit=20,
sat_shift_limit=60,
val_shift_limit=0,
p=0.6),
#transforms.Equalize(p=0.1),
#transforms.FancyPCA(p=0.05),
#transforms.RandomGridShuffle(p=0.1),
#A.OneOf([
# transforms.MotionBlur(blur_limit=(3, 9)),
# transforms.GaussianBlur(),
# transforms.MedianBlur()
# ], p=0.2),
transforms.ISONoise(p=.3),
transforms.GaussNoise(var_limit=255., p=.3),
#A.OneOf([
# transforms.GridDistortion(interpolation=cv2.INTER_AREA, distort_limit=[0.7, 0.7], p=0.5),
# transforms.OpticalDistortion(interpolation=cv2.INTER_AREA, p=.3),
# ], p=.3),
geometric.ElasticTransform(alpha=4, sigma=100, alpha_affine=100, interpolation=cv2.INTER_AREA, p=0.3),
transforms.CoarseDropout(),
transforms.Normalize(),
ToTensorV2()
])
return transforms_presize, transforms_postsize
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 get_train_transforms():
return A.Compose([
transforms.PadIfNeeded(600, 800),
geometric.ShiftScaleRotate(interpolation=cv2.INTER_LANCZOS4, p = 0.99, scale_limit=0.8),
geometric.Perspective(pad_mode=cv2.BORDER_REFLECT,interpolation=cv2.INTER_AREA),
crops.RandomResizedCrop(
TARGET_SIZE, TARGET_SIZE,
scale=(config['rrc_scale_min'], config['rrc_scale_max']),
interpolation=cv2.INTER_CUBIC,
p=1.0),
transforms.Transpose(),
transforms.Flip(),
transforms.CoarseDropout(),
transforms.CLAHE(p=.1),
transforms.RandomToneCurve(scale=.1),
transforms.RandomBrightnessContrast(
brightness_limit=.1,
contrast_limit=0.3,
p=.7),
transforms.HueSaturationValue(
hue_shift_limit=20,
sat_shift_limit=60,
val_shift_limit=0,
p=0.6),
transforms.RandomGridShuffle(p=0.1),
A.OneOf([
transforms.MotionBlur(blur_limit=(3, 9)),
transforms.GaussianBlur(),
transforms.MedianBlur()
], p=0.2),
transforms.ISONoise(p=.3),
transforms.GaussNoise(var_limit=255., p=.3),
A.OneOf([
transforms.GridDistortion(interpolation=cv2.INTER_AREA, distort_limit=[0.7, 0.7], p=0.5),
transforms.OpticalDistortion(interpolation=cv2.INTER_AREA, p=.3),
], p=.3),
geometric.ElasticTransform(alpha=4, sigma=100, alpha_affine=100, interpolation=cv2.INTER_AREA, p=0.3),
transforms.CoarseDropout(),
transforms.Normalize(),
ToTensorV2()
])
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 __init__(
self,
prob=0,
Flip_prob=0,
HueSaturationValue_prob=0,
RandomBrightnessContrast_prob=0,
crop_prob=0,
randomrotate90_prob=0,
elastictransform_prob=0,
gridistortion_prob=0,
opticaldistortion_prob=0,
verticalflip_prob=0,
horizontalflip_prob=0,
randomgamma_prob=0,
CoarseDropout_prob=0,
RGBShift_prob=0,
MotionBlur_prob=0,
MedianBlur_prob=0,
GaussianBlur_prob=0,
GaussNoise_prob=0,
ChannelShuffle_prob=0,
ColorJitter_prob=0,
):
super().__init__()
self.prob = prob
self.randomrotate90_prob = randomrotate90_prob
self.elastictransform_prob = elastictransform_prob
self.transforms = al.Compose(
[
transforms.RandomRotate90(p=randomrotate90_prob),
transforms.Flip(p=Flip_prob),
transforms.HueSaturationValue(p=HueSaturationValue_prob),
transforms.RandomBrightnessContrast(
p=RandomBrightnessContrast_prob),
transforms.Transpose(),
OneOf(
[
transforms.RandomCrop(220, 220, p=0.5),
transforms.CenterCrop(220, 220, p=0.5),
],
p=crop_prob,
),
ElasticTransform(
p=elastictransform_prob,
alpha=120,
sigma=120 * 0.05,
alpha_affine=120 * 0.03,
),
GridDistortion(p=gridistortion_prob),
OpticalDistortion(p=opticaldistortion_prob,
distort_limit=2,
shift_limit=0.5),
VerticalFlip(p=verticalflip_prob),
HorizontalFlip(p=horizontalflip_prob),
RandomGamma(p=randomgamma_prob),
RGBShift(p=RGBShift_prob),
MotionBlur(p=MotionBlur_prob, blur_limit=7),
MedianBlur(p=MedianBlur_prob, blur_limit=9),
GaussianBlur(p=GaussianBlur_prob, blur_limit=9),
GaussNoise(p=GaussNoise_prob),
ChannelShuffle(p=ChannelShuffle_prob),
CoarseDropout(p=CoarseDropout_prob,
max_holes=8,
max_height=32,
max_width=32),
ColorJitter(p=ColorJitter_prob)
# transforms.Resize(352, 352),
# transforms.Normalize(
# mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)
# ),
],
p=self.prob,
)
from glob import glob
train_img_paths = []
train_mask_paths = []
train_data_path = ["data/kvasir-seg/TrainDataset"]
for i in train_data_path:
train_img_paths.extend(glob(os.path.join(i, "images", "*")))
train_mask_paths.extend(glob(os.path.join(i, "masks", "*")))
train_img_paths.sort()
train_mask_paths.sort()
transforms = al.Compose(
[
transforms.RandomRotate90(),
transforms.Flip(),
transforms.HueSaturationValue(),
transforms.RandomBrightnessContrast(),
transforms.Transpose(),
OneOf(
[
transforms.RandomCrop(220, 220, p=0.5),
transforms.CenterCrop(220, 220, p=0.5),
],
p=1,
),
# transforms.Resize(352,352),
# transforms.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),
],
p=1,
)
dataset = KvasirDataset(train_img_paths,
def main():
# config = vars(parse_args_func())
#config_file = "../configs/config_v1.json"
args = vars(parse_args_func())
config_file = args['config']
config_dict = json.loads(open(config_file, 'rt').read())
# config_dict = json.loads(open(sys.argv[1], 'rt').read())
file_dict = config_dict['file_path']
config = config_dict['opt_config']
input_folder = file_dict['input_path'] # '../inputs'
checkpoint_folder = file_dict['checkpoint_path'] # '../checkpoint'
model_folder = file_dict['model_path'] # '../models'
if 'False' in config['deep_supervision']:
config['deep_supervision'] = False
else:
config['deep_supervision'] = True
if 'False' in config['nesterov']:
config['nesterov'] = False
else:
config['nesterov'] = True
if 'None' in config['name']:
config['name'] = None
if config['name'] is None:
config['name'] = '%s_%s_segmodel' % (config['dataset'], config['arch'])
os.makedirs(os.path.join(model_folder, '%s' % config['name']),
exist_ok=True)
print('-' * 20)
for key in config:
print('%s: %s' % (key, config[key]))
print('-' * 20)
with open(os.path.join(model_folder, '%s/config.yml' % config['name']),
'w') as f:
yaml.dump(config, f)
# define loss function (criterion)
if config['loss'] == 'BCEWithLogitsLoss':
criterion = nn.BCEWithLogitsLoss().cuda()
else:
criterion = losses.__dict__[config['loss']]().cuda()
cudnn.benchmark = True
# create model
if 'False' in config['resume']:
config['resume'] = False
else:
config['resume'] = True
# Data loading code
img_ids = glob(
os.path.join(input_folder, config['dataset'], 'images', 'training',
'*' + config['img_ext']))
train_img_ids = [os.path.splitext(os.path.basename(p))[0] for p in img_ids]
img_ids = glob(
os.path.join(input_folder, config['val_dataset'], 'images',
'validation', '*' + config['img_ext']))
val_img_ids = [os.path.splitext(os.path.basename(p))[0] for p in img_ids]
img_ids = glob(
os.path.join(input_folder, config['val_dataset'], 'images', 'test',
'*' + config['img_ext']))
test_img_ids = [os.path.splitext(os.path.basename(p))[0] for p in img_ids]
mean = [0.485, 0.456, 0.406]
std = [0.229, 0.224, 0.225]
train_transform = Compose([
# transforms.RandomScale ([config['scale_min'], config['scale_max']]),
# transforms.RandomRotate90(),
transforms.Rotate([config['rotate_min'], config['rotate_max']],
value=mean,
mask_value=0),
# transforms.GaussianBlur (),
transforms.Flip(),
# transforms.HorizontalFlip (),
transforms.HueSaturationValue(hue_shift_limit=10,
sat_shift_limit=10,
val_shift_limit=10),
transforms.RandomBrightnessContrast(brightness_limit=0.10,
contrast_limit=0.10,
brightness_by_max=True),
transforms.Resize(config['input_h'], config['input_w']),
transforms.Normalize(mean=mean, std=std),
])
val_transform = Compose([
transforms.Resize(config['input_h'], config['input_w']),
transforms.Normalize(mean=mean, std=std),
])
train_dataset = Dataset(img_ids=train_img_ids,
img_dir=os.path.join(input_folder,
config['dataset'], 'images',
'training'),
mask_dir=os.path.join(input_folder,
config['dataset'],
'annotations', 'training'),
img_ext=config['img_ext'],
mask_ext=config['mask_ext'],
num_classes=config['num_classes'],
input_channels=config['input_channels'],
transform=train_transform)
val_dataset = Dataset(img_ids=val_img_ids,
img_dir=os.path.join(input_folder, config['dataset'],
'images', 'validation'),
mask_dir=os.path.join(input_folder,
config['dataset'],
'annotations', 'validation'),
img_ext=config['img_ext'],
mask_ext=config['mask_ext'],
num_classes=config['num_classes'],
input_channels=config['input_channels'],
transform=val_transform)
test_dataset = Dataset(img_ids=val_img_ids,
img_dir=os.path.join(input_folder,
config['dataset'], 'images',
'test'),
mask_dir=os.path.join(input_folder,
config['dataset'],
'annotations', 'test'),
img_ext=config['img_ext'],
mask_ext=config['mask_ext'],
num_classes=config['num_classes'],
input_channels=config['input_channels'],
transform=val_transform)
train_loader = torch.utils.data.DataLoader(
train_dataset,
batch_size=config['batch_size'],
shuffle=True,
num_workers=config['num_workers'],
drop_last=True)
val_loader = torch.utils.data.DataLoader(
val_dataset,
batch_size=1, # config['batch_size'],
shuffle=False,
num_workers=config['num_workers'],
drop_last=False)
test_loader = torch.utils.data.DataLoader(
test_dataset,
batch_size=1, # config['batch_size'],
shuffle=False,
num_workers=config['num_workers'],
drop_last=False)
log = OrderedDict([
('epoch', []),
('lr', []),
('loss', []),
('iou', []),
('dice', []),
('val_loss', []),
('val_iou', []),
('val_dice', []),
])
if not os.path.isdir(checkpoint_folder):
os.mkdir(checkpoint_folder)
# create generator model
#val_config = config_dict['config']
generator_name = config['generator_name']
with open(os.path.join(model_folder, '%s/config.yml' % generator_name),
'r') as f:
g_config = yaml.load(f, Loader=yaml.FullLoader)
generator = Generator(g_config)
generator.initialize_with_srresnet(model_folder, g_config)
lr = config['gan_lr']
# Initialize generator's optimizer
optimizer_g = torch.optim.Adam(params=filter(lambda p: p.requires_grad,
generator.parameters()),
lr=lr)
#params = filter(lambda p: p.requires_grad, generator.parameters())
#optimizer_g, scheduler_g = optimizer_scheduler(params, config)
# Discriminator
# Discriminator parameters
num_classes = config['num_classes']
kernel_size_d = 3 # kernel size in all convolutional blocks
n_channels_d = 64 # number of output channels in the first convolutional block, after which it is doubled in every 2nd block thereafter
n_blocks_d = 8 # number of convolutional blocks
fc_size_d = 1024 # size of the first fully connected layer
discriminator = Discriminator(num_classes,
kernel_size=kernel_size_d,
n_channels=n_channels_d,
n_blocks=n_blocks_d,
fc_size=fc_size_d)
# Initialize discriminator's optimizer
optimizer_d = torch.optim.Adam(params=filter(lambda p: p.requires_grad,
discriminator.parameters()),
lr=lr)
#params = filter(lambda p: p.requires_grad, discriminator.parameters())
#optimizer_d, scheduler_d = optimizer_scheduler(params, config)
adversarial_loss_criterion = nn.BCEWithLogitsLoss()
content_loss_criterion = nn.MSELoss()
generator = generator.cuda()
discriminator = discriminator.cuda()
#truncated_vgg19 = truncated_vgg19.cuda()
content_loss_criterion = content_loss_criterion.cuda()
adversarial_loss_criterion = adversarial_loss_criterion.cuda()
generator = torch.nn.DataParallel(generator)
discriminator = torch.nn.DataParallel(discriminator)
if not os.path.isdir(checkpoint_folder):
os.mkdir(checkpoint_folder)
log_name = config['name']
log_dir = os.path.join(checkpoint_folder, log_name)
writer = SummaryWriter(logdir=log_dir)
best_iou = 0
trigger = 0
Best_dice = 0
iou_AtBestDice = 0
start_epoch = 0
for epoch in range(start_epoch, config['epochs']):
print('Epoch [%d/%d]' % (epoch, config['epochs']))
# train for one epoch
train_log = train(epoch, config, train_loader, generator,
discriminator, criterion, adversarial_loss_criterion,
content_loss_criterion, optimizer_g, optimizer_d)
# evaluate on validation set
val_log = validate(config, val_loader, generator, criterion)
test_log = validate(config, test_loader, generator, criterion)
if Best_dice < test_log['dice']:
Best_dice = test_log['dice']
iou_AtBestDice = test_log['iou']
print(
'loss %.4f - iou %.4f - dice %.4f - val_loss %.4f - val_iou %.4f - val_dice %.4f - test_iou %.4f - test_dice %.4f - Best_dice %.4f - iou_AtBestDice %.4f'
% (train_log['loss'], train_log['iou'], train_log['dice'],
val_log['loss'], val_log['iou'], val_log['dice'],
test_log['iou'], test_log['dice'], Best_dice, iou_AtBestDice))
save_tensorboard(writer, train_log, val_log, test_log, epoch)
log['epoch'].append(epoch)
log['lr'].append(config['lr'])
log['loss'].append(train_log['loss'])
log['iou'].append(train_log['iou'])
log['dice'].append(train_log['dice'])
log['val_loss'].append(val_log['loss'])
log['val_iou'].append(val_log['iou'])
log['val_dice'].append(val_log['dice'])
pd.DataFrame(log).to_csv(os.path.join(model_folder,
'%s/log.csv' % config['name']),
index=False)
trigger += 1
if test_log['iou'] > best_iou:
torch.save(
generator.state_dict(),
os.path.join(model_folder, '%s/model.pth' % config['name']))
best_iou = test_log['iou']
print("=> saved best model")
trigger = 0
# early stopping
if config['early_stopping'] >= 0 and trigger >= config[
'early_stopping']:
print("=> early stopping")
break
torch.cuda.empty_cache()
def main():
config = vars(parse_args())
if config['name'] is None:
config['name'] = '%s_%s' % (config['arch'],
datetime.now().strftime('%m%d%H'))
config['num_filters'] = [int(n) for n in config['num_filters'].split(',')]
if not os.path.exists('models/detection/%s' % config['name']):
os.makedirs('models/detection/%s' % config['name'])
if config['resume']:
with open('models/detection/%s/config.yml' % config['name'], 'r') as f:
config = yaml.load(f, Loader=yaml.FullLoader)
config['resume'] = True
with open('models/detection/%s/config.yml' % config['name'], 'w') as f:
yaml.dump(config, f)
print('-' * 20)
for key in config.keys():
print('- %s: %s' % (key, str(config[key])))
print('-' * 20)
cudnn.benchmark = True
df = pd.read_csv('inputs/train.csv')
img_paths = np.array('inputs/train_images/' + df['ImageId'].values +
'.jpg')
mask_paths = np.array('inputs/train_masks/' + df['ImageId'].values +
'.jpg')
labels = np.array(
[convert_str_to_labels(s) for s in df['PredictionString']])
test_img_paths = None
test_mask_paths = None
test_outputs = None
if config['pseudo_label'] is not None:
test_df = pd.read_csv('inputs/sample_submission.csv')
test_img_paths = np.array('inputs/test_images/' +
test_df['ImageId'].values + '.jpg')
test_mask_paths = np.array('inputs/test_masks/' +
test_df['ImageId'].values + '.jpg')
ext = os.path.splitext(config['pseudo_label'])[1]
if ext == '.pth':
test_outputs = torch.load('outputs/raw/test/%s' %
config['pseudo_label'])
elif ext == '.csv':
test_labels = pd.read_csv('outputs/submissions/test/%s' %
config['pseudo_label'])
null_idx = test_labels.isnull().any(axis=1)
test_img_paths = test_img_paths[~null_idx]
test_mask_paths = test_mask_paths[~null_idx]
test_labels = test_labels.dropna()
test_labels = np.array([
convert_str_to_labels(
s, names=['pitch', 'yaw', 'roll', 'x', 'y', 'z', 'score'])
for s in test_labels['PredictionString']
])
print(test_labels)
else:
raise NotImplementedError
if config['resume']:
checkpoint = torch.load('models/detection/%s/checkpoint.pth.tar' %
config['name'])
heads = OrderedDict([
('hm', 1),
('reg', 2),
('depth', 1),
])
if config['rot'] == 'eular':
heads['eular'] = 3
elif config['rot'] == 'trig':
heads['trig'] = 6
elif config['rot'] == 'quat':
heads['quat'] = 4
else:
raise NotImplementedError
if config['wh']:
heads['wh'] = 2
criterion = OrderedDict()
for head in heads.keys():
criterion[head] = losses.__dict__[config[head + '_loss']]().cuda()
train_transform = Compose([
transforms.ShiftScaleRotate(shift_limit=config['shift_limit'],
scale_limit=0,
rotate_limit=0,
border_mode=cv2.BORDER_CONSTANT,
value=0,
p=config['shift_p'])
if config['shift'] else NoOp(),
OneOf([
transforms.HueSaturationValue(hue_shift_limit=config['hue_limit'],
sat_shift_limit=config['sat_limit'],
val_shift_limit=config['val_limit'],
p=config['hsv_p'])
if config['hsv'] else NoOp(),
transforms.RandomBrightness(
limit=config['brightness_limit'],
p=config['brightness_p'],
) if config['brightness'] else NoOp(),
transforms.RandomContrast(
limit=config['contrast_limit'],
p=config['contrast_p'],
) if config['contrast'] else NoOp(),
],
p=1),
transforms.ISONoise(p=config['iso_noise_p'], )
if config['iso_noise'] else NoOp(),
transforms.CLAHE(p=config['clahe_p'], ) if config['clahe'] else NoOp(),
],
keypoint_params=KeypointParams(
format='xy', remove_invisible=False))
val_transform = None
folds = []
best_losses = []
# best_scores = []
kf = KFold(n_splits=config['n_splits'], shuffle=True, random_state=41)
for fold, (train_idx, val_idx) in enumerate(kf.split(img_paths)):
print('Fold [%d/%d]' % (fold + 1, config['n_splits']))
if (config['resume'] and fold < checkpoint['fold'] - 1) or (
not config['resume']
and os.path.exists('models/%s/model_%d.pth' %
(config['name'], fold + 1))):
log = pd.read_csv('models/detection/%s/log_%d.csv' %
(config['name'], fold + 1))
best_loss = log.loc[log['val_loss'].values.argmin(), 'val_loss']
# best_loss, best_score = log.loc[log['val_loss'].values.argmin(), ['val_loss', 'val_score']].values
folds.append(str(fold + 1))
best_losses.append(best_loss)
# best_scores.append(best_score)
continue
train_img_paths, val_img_paths = img_paths[train_idx], img_paths[
val_idx]
train_mask_paths, val_mask_paths = mask_paths[train_idx], mask_paths[
val_idx]
train_labels, val_labels = labels[train_idx], labels[val_idx]
if config['pseudo_label'] is not None:
train_img_paths = np.hstack((train_img_paths, test_img_paths))
train_mask_paths = np.hstack((train_mask_paths, test_mask_paths))
train_labels = np.hstack((train_labels, test_labels))
# train
train_set = Dataset(
train_img_paths,
train_mask_paths,
train_labels,
input_w=config['input_w'],
input_h=config['input_h'],
transform=train_transform,
lhalf=config['lhalf'],
hflip=config['hflip_p'] if config['hflip'] else 0,
scale=config['scale_p'] if config['scale'] else 0,
scale_limit=config['scale_limit'],
# test_img_paths=test_img_paths,
# test_mask_paths=test_mask_paths,
# test_outputs=test_outputs,
)
train_loader = torch.utils.data.DataLoader(
train_set,
batch_size=config['batch_size'],
shuffle=True,
num_workers=config['num_workers'],
# pin_memory=True,
)
val_set = Dataset(val_img_paths,
val_mask_paths,
val_labels,
input_w=config['input_w'],
input_h=config['input_h'],
transform=val_transform,
lhalf=config['lhalf'])
val_loader = torch.utils.data.DataLoader(
val_set,
batch_size=config['batch_size'],
shuffle=False,
num_workers=config['num_workers'],
# pin_memory=True,
)
# create model
model = get_model(config['arch'],
heads=heads,
head_conv=config['head_conv'],
num_filters=config['num_filters'],
dcn=config['dcn'],
gn=config['gn'],
ws=config['ws'],
freeze_bn=config['freeze_bn'])
model = model.cuda()
if config['load_model'] is not None:
model.load_state_dict(
torch.load('models/detection/%s/model_%d.pth' %
(config['load_model'], fold + 1)))
params = filter(lambda p: p.requires_grad, model.parameters())
if config['optimizer'] == 'Adam':
optimizer = optim.Adam(params,
lr=config['lr'],
weight_decay=config['weight_decay'])
elif config['optimizer'] == 'AdamW':
optimizer = optim.AdamW(params,
lr=config['lr'],
weight_decay=config['weight_decay'])
elif config['optimizer'] == 'RAdam':
optimizer = RAdam(params,
lr=config['lr'],
weight_decay=config['weight_decay'])
elif config['optimizer'] == 'SGD':
optimizer = optim.SGD(params,
lr=config['lr'],
momentum=config['momentum'],
nesterov=config['nesterov'],
weight_decay=config['weight_decay'])
else:
raise NotImplementedError
if config['apex']:
amp.initialize(model, optimizer, opt_level='O1')
if config['scheduler'] == 'CosineAnnealingLR':
scheduler = lr_scheduler.CosineAnnealingLR(
optimizer, T_max=config['epochs'], eta_min=config['min_lr'])
elif config['scheduler'] == 'ReduceLROnPlateau':
scheduler = lr_scheduler.ReduceLROnPlateau(
optimizer,
factor=config['factor'],
patience=config['patience'],
verbose=1,
min_lr=config['min_lr'])
elif config['scheduler'] == 'MultiStepLR':
scheduler = lr_scheduler.MultiStepLR(
optimizer,
milestones=[int(e) for e in config['milestones'].split(',')],
gamma=config['gamma'])
else:
raise NotImplementedError
log = {
'epoch': [],
'loss': [],
# 'score': [],
'val_loss': [],
# 'val_score': [],
}
best_loss = float('inf')
# best_score = float('inf')
start_epoch = 0
if config['resume'] and fold == checkpoint['fold'] - 1:
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/detection/%s/log_%d.csv' %
(config['name'], fold + 1)).to_dict(orient='list')
best_loss = checkpoint['best_loss']
for epoch in range(start_epoch, config['epochs']):
print('Epoch [%d/%d]' % (epoch + 1, config['epochs']))
# train for one epoch
train_loss = train(config, heads, train_loader, model, criterion,
optimizer, epoch)
# evaluate on validation set
val_loss = validate(config, heads, val_loader, model, criterion)
if config['scheduler'] == 'CosineAnnealingLR':
scheduler.step()
elif config['scheduler'] == 'ReduceLROnPlateau':
scheduler.step(val_loss)
print('loss %.4f - val_loss %.4f' % (train_loss, val_loss))
# print('loss %.4f - score %.4f - val_loss %.4f - val_score %.4f'
# % (train_loss, train_score, val_loss, val_score))
log['epoch'].append(epoch)
log['loss'].append(train_loss)
# log['score'].append(train_score)
log['val_loss'].append(val_loss)
# log['val_score'].append(val_score)
pd.DataFrame(log).to_csv('models/detection/%s/log_%d.csv' %
(config['name'], fold + 1),
index=False)
if val_loss < best_loss:
torch.save(
model.state_dict(), 'models/detection/%s/model_%d.pth' %
(config['name'], fold + 1))
best_loss = val_loss
# best_score = val_score
print("=> saved best model")
state = {
'fold': fold + 1,
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'best_loss': best_loss,
'optimizer': optimizer.state_dict(),
'scheduler': scheduler.state_dict(),
}
torch.save(
state,
'models/detection/%s/checkpoint.pth.tar' % config['name'])
print('val_loss: %f' % best_loss)
# print('val_score: %f' % best_score)
folds.append(str(fold + 1))
best_losses.append(best_loss)
# best_scores.append(best_score)
results = pd.DataFrame({
'fold':
folds + ['mean'],
'best_loss':
best_losses + [np.mean(best_losses)],
# 'best_score': best_scores + [np.mean(best_scores)],
})
print(results)
results.to_csv('models/detection/%s/results.csv' % config['name'],
index=False)
del model
torch.cuda.empty_cache()
del train_set, train_loader
del val_set, val_loader
gc.collect()
if not config['cv']:
break
def main():
config = vars(parse_args())
if config['name'] is None:
if config['deep_supervision']:
config['name'] = '%s_%s_wDS' % (config['dataset'], config['arch'])
else:
config['name'] = '%s_%s_woDS' % (config['dataset'], config['arch'])
os.makedirs('models/%s' % config['name'], exist_ok=True)
print('-' * 20)
for key in config:
print('%s: %s' % (key, config[key]))
print('-' * 20)
with open('models/%s/config.yml' % config['name'], 'w') as f:
yaml.dump(config, f)
# define loss function (criterion)
if config['loss'] == 'BCEWithLogitsLoss':
criterion = nn.BCEWithLogitsLoss().cuda()
else:
criterion = losses.__dict__[config['loss']]().cuda()
cudnn.benchmark = True
# create model
print("=> creating model %s" % config['arch'])
model = archs.__dict__[config['arch']](config['num_classes'],
config['input_channels'],
config['deep_supervision'])
model = model.cuda()
params = filter(lambda p: p.requires_grad, model.parameters())
if config['optimizer'] == 'Adam':
optimizer = optim.Adam(params,
lr=config['lr'],
weight_decay=config['weight_decay'])
elif config['optimizer'] == 'SGD':
optimizer = optim.SGD(params,
lr=config['lr'],
momentum=config['momentum'],
nesterov=config['nesterov'],
weight_decay=config['weight_decay'])
else:
raise NotImplementedError
if config['scheduler'] == 'CosineAnnealingLR':
scheduler = lr_scheduler.CosineAnnealingLR(optimizer,
T_max=config['epochs'],
eta_min=config['min_lr'])
elif config['scheduler'] == 'ReduceLROnPlateau':
scheduler = lr_scheduler.ReduceLROnPlateau(optimizer,
factor=config['factor'],
patience=config['patience'],
verbose=1,
min_lr=config['min_lr'])
elif config['scheduler'] == 'MultiStepLR':
scheduler = lr_scheduler.MultiStepLR(
optimizer,
milestones=[int(e) for e in config['milestones'].split(',')],
gamma=config['gamma'])
elif config['scheduler'] == 'ConstantLR':
scheduler = None
else:
raise NotImplementedError
# Data loading code
img_ids = glob(
os.path.join('inputs', config['dataset'], 'images',
'*' + config['img_ext']))
img_ids = [os.path.splitext(os.path.basename(p))[0] for p in img_ids]
train_img_ids, val_img_ids = train_test_split(img_ids,
test_size=0.2,
random_state=41)
#######################
train_img_ids = img_ids
#######################
train_transform = Compose([
transforms.RandomRotate90(),
transforms.Flip(),
OneOf([
transforms.HueSaturationValue(),
transforms.RandomBrightness(),
transforms.RandomContrast(),
],
p=1),
transforms.Resize(config['input_h'], config['input_w']),
transforms.Normalize(),
])
val_transform = Compose([
transforms.Resize(config['input_h'], config['input_w']),
transforms.Normalize(),
])
train_dataset = Dataset(img_ids=train_img_ids,
img_dir=os.path.join('inputs', config['dataset'],
'images'),
mask_dir=os.path.join('inputs', config['dataset'],
'masks'),
img_ext=config['img_ext'],
mask_ext=config['mask_ext'],
num_classes=config['num_classes'],
transform=train_transform)
val_dataset = Dataset(img_ids=val_img_ids,
img_dir=os.path.join('inputs', config['dataset'],
'images'),
mask_dir=os.path.join('inputs', config['dataset'],
'masks'),
img_ext=config['img_ext'],
mask_ext=config['mask_ext'],
num_classes=config['num_classes'],
transform=val_transform)
train_loader = torch.utils.data.DataLoader(
train_dataset,
batch_size=config['batch_size'],
shuffle=True,
num_workers=config['num_workers'],
drop_last=True)
val_loader = torch.utils.data.DataLoader(val_dataset,
batch_size=config['batch_size'],
shuffle=False,
num_workers=config['num_workers'],
drop_last=False)
log = OrderedDict([
('epoch', []),
('lr', []),
('loss', []),
('iou', []),
('val_loss', []),
('val_iou', []),
])
best_iou = 0
trigger = 0
for epoch in range(config['epochs']):
print('Epoch [%d/%d]' % (epoch, config['epochs']))
# train for one epoch
train_log = train(config, train_loader, model, criterion, optimizer)
# evaluate on validation set
val_log = validate(config, val_loader, model, criterion)
if config['scheduler'] == 'CosineAnnealingLR':
scheduler.step()
elif config['scheduler'] == 'ReduceLROnPlateau':
scheduler.step(val_log['loss'])
print('loss %.4f - iou %.4f - val_loss %.4f - val_iou %.4f' %
(train_log['loss'], train_log['iou'], val_log['loss'],
val_log['iou']))
log['epoch'].append(epoch)
log['lr'].append(config['lr'])
log['loss'].append(train_log['loss'])
log['iou'].append(train_log['iou'])
log['val_loss'].append(val_log['loss'])
log['val_iou'].append(val_log['iou'])
pd.DataFrame(log).to_csv('models/%s/log.csv' % config['name'],
index=False)
trigger += 1
if val_log['iou'] > best_iou:
torch.save(model.state_dict(),
'models/%s/model.pth' % config['name'])
best_iou = val_log['iou']
print("=> saved best model")
trigger = 0
# early stopping
if config['early_stopping'] >= 0 and trigger >= config[
'early_stopping']:
print("=> early stopping")
break
torch.cuda.empty_cache()
def main():
config = vars(parse_args())
if config['name'] is None:
config['name'] = '%s_%s' % (config['arch'], datetime.now().strftime('%m%d%H'))
if not os.path.exists('models/pose/%s' % config['name']):
os.makedirs('models/pose/%s' % config['name'])
if config['resume']:
with open('models/pose/%s/config.yml' % config['name'], 'r') as f:
config = yaml.load(f, Loader=yaml.FullLoader)
config['resume'] = True
with open('models/pose/%s/config.yml' % config['name'], 'w') as f:
yaml.dump(config, f)
print('-'*20)
for key in config.keys():
print('- %s: %s' % (key, str(config[key])))
print('-'*20)
cudnn.benchmark = True
df = pd.read_csv('inputs/train.csv')
img_ids = df['ImageId'].values
pose_df = pd.read_csv('processed/pose_train.csv')
pose_df['img_path'] = 'processed/pose_images/train/' + pose_df['img_path']
if config['resume']:
checkpoint = torch.load('models/pose/%s/checkpoint.pth.tar' % config['name'])
if config['rot'] == 'eular':
num_outputs = 3
elif config['rot'] == 'trig':
num_outputs = 6
elif config['rot'] == 'quat':
num_outputs = 4
else:
raise NotImplementedError
if config['loss'] == 'L1Loss':
criterion = nn.L1Loss().cuda()
elif config['loss'] == 'MSELoss':
criterion = nn.MSELoss().cuda()
else:
raise NotImplementedError
train_transform = Compose([
transforms.ShiftScaleRotate(
shift_limit=config['shift_limit'],
scale_limit=0,
rotate_limit=0,
border_mode=cv2.BORDER_CONSTANT,
value=0,
p=config['shift_p']
) if config['shift'] else NoOp(),
OneOf([
transforms.HueSaturationValue(
hue_shift_limit=config['hue_limit'],
sat_shift_limit=config['sat_limit'],
val_shift_limit=config['val_limit'],
p=config['hsv_p']
) if config['hsv'] else NoOp(),
transforms.RandomBrightness(
limit=config['brightness_limit'],
p=config['brightness_p'],
) if config['brightness'] else NoOp(),
transforms.RandomContrast(
limit=config['contrast_limit'],
p=config['contrast_p'],
) if config['contrast'] else NoOp(),
], p=1),
transforms.ISONoise(
p=config['iso_noise_p'],
) if config['iso_noise'] else NoOp(),
transforms.CLAHE(
p=config['clahe_p'],
) if config['clahe'] else NoOp(),
transforms.Resize(config['input_w'], config['input_h']),
transforms.Normalize(),
ToTensor(),
])
val_transform = Compose([
transforms.Resize(config['input_w'], config['input_h']),
transforms.Normalize(),
ToTensor(),
])
folds = []
best_losses = []
kf = KFold(n_splits=config['n_splits'], shuffle=True, random_state=41)
for fold, (train_idx, val_idx) in enumerate(kf.split(img_ids)):
print('Fold [%d/%d]' %(fold + 1, config['n_splits']))
if (config['resume'] and fold < checkpoint['fold'] - 1) or (not config['resume'] and os.path.exists('pose_models/%s/model_%d.pth' % (config['name'], fold+1))):
log = pd.read_csv('models/pose/%s/log_%d.csv' %(config['name'], fold+1))
best_loss = log.loc[log['val_loss'].values.argmin(), 'val_loss']
# best_loss, best_score = log.loc[log['val_loss'].values.argmin(), ['val_loss', 'val_score']].values
folds.append(str(fold + 1))
best_losses.append(best_loss)
# best_scores.append(best_score)
continue
train_img_ids, val_img_ids = img_ids[train_idx], img_ids[val_idx]
train_img_paths = []
train_labels = []
for img_id in train_img_ids:
tmp = pose_df.loc[pose_df.ImageId == img_id]
img_path = tmp['img_path'].values
train_img_paths.append(img_path)
yaw = tmp['yaw'].values
pitch = tmp['pitch'].values
roll = tmp['roll'].values
roll = rotate(roll, np.pi)
if config['rot'] == 'eular':
label = np.array([
yaw,
pitch,
roll
]).T
elif config['rot'] == 'trig':
label = np.array([
np.cos(yaw),
np.sin(yaw),
np.cos(pitch),
np.sin(pitch),
np.cos(roll),
np.sin(roll),
]).T
elif config['rot'] == 'quat':
raise NotImplementedError
else:
raise NotImplementedError
train_labels.append(label)
train_img_paths = np.hstack(train_img_paths)
train_labels = np.vstack(train_labels)
val_img_paths = []
val_labels = []
for img_id in val_img_ids:
tmp = pose_df.loc[pose_df.ImageId == img_id]
img_path = tmp['img_path'].values
val_img_paths.append(img_path)
yaw = tmp['yaw'].values
pitch = tmp['pitch'].values
roll = tmp['roll'].values
roll = rotate(roll, np.pi)
if config['rot'] == 'eular':
label = np.array([
yaw,
pitch,
roll
]).T
elif config['rot'] == 'trig':
label = np.array([
np.cos(yaw),
np.sin(yaw),
np.cos(pitch),
np.sin(pitch),
np.cos(roll),
np.sin(roll),
]).T
elif config['rot'] == 'quat':
raise NotImplementedError
else:
raise NotImplementedError
val_labels.append(label)
val_img_paths = np.hstack(val_img_paths)
val_labels = np.vstack(val_labels)
# train
train_set = PoseDataset(
train_img_paths,
train_labels,
transform=train_transform,
)
train_loader = torch.utils.data.DataLoader(
train_set,
batch_size=config['batch_size'],
shuffle=True,
num_workers=config['num_workers'],
# pin_memory=True,
)
val_set = PoseDataset(
val_img_paths,
val_labels,
transform=val_transform,
)
val_loader = torch.utils.data.DataLoader(
val_set,
batch_size=config['batch_size'],
shuffle=False,
num_workers=config['num_workers'],
# pin_memory=True,
)
# create model
model = get_pose_model(config['arch'],
num_outputs=num_outputs,
freeze_bn=config['freeze_bn'])
model = model.cuda()
params = filter(lambda p: p.requires_grad, model.parameters())
if config['optimizer'] == 'Adam':
optimizer = optim.Adam(params, lr=config['lr'], weight_decay=config['weight_decay'])
elif config['optimizer'] == 'AdamW':
optimizer = optim.AdamW(params, lr=config['lr'], weight_decay=config['weight_decay'])
elif config['optimizer'] == 'RAdam':
optimizer = RAdam(params, lr=config['lr'], weight_decay=config['weight_decay'])
elif config['optimizer'] == 'SGD':
optimizer = optim.SGD(params, lr=config['lr'], momentum=config['momentum'],
nesterov=config['nesterov'], weight_decay=config['weight_decay'])
else:
raise NotImplementedError
if config['scheduler'] == 'CosineAnnealingLR':
scheduler = lr_scheduler.CosineAnnealingLR(optimizer, T_max=config['epochs'], eta_min=config['min_lr'])
elif config['scheduler'] == 'ReduceLROnPlateau':
scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, factor=config['factor'], patience=config['patience'],
verbose=1, min_lr=config['min_lr'])
elif config['scheduler'] == 'MultiStepLR':
scheduler = lr_scheduler.MultiStepLR(optimizer, milestones=[int(e) for e in config['milestones'].split(',')], gamma=config['gamma'])
else:
raise NotImplementedError
log = {
'epoch': [],
'loss': [],
# 'score': [],
'val_loss': [],
# 'val_score': [],
}
best_loss = float('inf')
# best_score = float('inf')
start_epoch = 0
if config['resume'] and fold == checkpoint['fold'] - 1:
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/pose/%s/log_%d.csv' % (config['name'], fold+1)).to_dict(orient='list')
best_loss = checkpoint['best_loss']
for epoch in range(start_epoch, config['epochs']):
print('Epoch [%d/%d]' % (epoch + 1, config['epochs']))
# train for one epoch
train_loss = train(config, train_loader, model, criterion, optimizer, epoch)
# evaluate on validation set
val_loss = validate(config, val_loader, model, criterion)
if config['scheduler'] == 'CosineAnnealingLR':
scheduler.step()
elif config['scheduler'] == 'ReduceLROnPlateau':
scheduler.step(val_loss)
print('loss %.4f - val_loss %.4f' % (train_loss, val_loss))
# print('loss %.4f - score %.4f - val_loss %.4f - val_score %.4f'
# % (train_loss, train_score, val_loss, val_score))
log['epoch'].append(epoch)
log['loss'].append(train_loss)
# log['score'].append(train_score)
log['val_loss'].append(val_loss)
# log['val_score'].append(val_score)
pd.DataFrame(log).to_csv('models/pose/%s/log_%d.csv' % (config['name'], fold+1), index=False)
if val_loss < best_loss:
torch.save(model.state_dict(), 'models/pose/%s/model_%d.pth' % (config['name'], fold+1))
best_loss = val_loss
# best_score = val_score
print("=> saved best model")
state = {
'fold': fold + 1,
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'best_loss': best_loss,
'optimizer': optimizer.state_dict(),
'scheduler': scheduler.state_dict(),
}
torch.save(state, 'models/pose/%s/checkpoint.pth.tar' % config['name'])
print('val_loss: %f' % best_loss)
# print('val_score: %f' % best_score)
folds.append(str(fold + 1))
best_losses.append(best_loss)
# best_scores.append(best_score)
results = pd.DataFrame({
'fold': folds + ['mean'],
'best_loss': best_losses + [np.mean(best_losses)],
# 'best_score': best_scores + [np.mean(best_scores)],
})
print(results)
results.to_csv('models/pose/%s/results.csv' % config['name'], index=False)
del model
torch.cuda.empty_cache()
del train_set, train_loader
del val_set, val_loader
gc.collect()
if not config['cv']:
break
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
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
def main():
config = vars(parse_args())
now = datetime.datetime.now()
if config["name"] is None:
if config["deep_supervision"]:
config["name"] = "%s_%s_wDS_%s" % (
config["dataset"],
config["arch"],
now.strftime("%Y%m%d_%H%M%S"),
)
else:
config["name"] = "%s_%s_woDS_%s" % (
config["dataset"],
config["arch"],
now.strftime("%Y%m%d_%H%M%S"),
)
output_path = os.path.join(cfg.UNET_RESULTS_DIR, config["name"])
try:
os.makedirs(output_path, exist_ok=True)
except Exception as e:
print(e)
models_path = os.path.join(output_path, "models")
os.mkdir(models_path)
with open(os.path.join(models_path, "config.yml"), "w") as f:
yaml.dump(config, f)
print("-" * 20)
for key in config:
print("%s: %s" % (key, config[key]))
print("-" * 20)
# Tensorboad 用のログを記録するディレクトリパス
log_dir = os.path.join(output_path, "log")
os.mkdir(log_dir)
writer = SummaryWriter(log_dir=log_dir)
# define loss function(criterion)
if config["loss"] == "BCEWithLogitsLoss":
criterion = nn.BCEWithLogitsLoss().cuda()
else:
criterion = losses.__dict__[config["loss"]]().cuda()
cudnn.benchmark = True
# create model
print("=> creating model %s" % config["arch"])
model = archs.__dict__[config["arch"]](config["num_classes"],
config["input_channels"],
config["deep_supervision"])
model = model.cuda()
# モデルを TensorBorad で表示するため，ログに保存
# image = torch.randn(1, 3, 2224, 224)
# writer.add_graph(model, image)
params = filter(lambda p: p.requires_grad, model.parameters())
if config["optimizer"] == "Adam":
optimizer = optim.Adam(params,
lr=config["lr"],
weight_decay=config["weight_decay"])
elif config["optimizer"] == "SGD":
optimizer = optim.SGD(
params,
lr=config["lr"],
momentum=config["momentum"],
nesterov=config["nesterov"],
weight_decay=config["weight_decay"],
)
else:
raise NotImplementedError
# scheduler
if config["scheduler"] == "CosineAnnealingLR":
scheduler = lr_scheduler.CosineAnnealingLR(optimizer=optimizer,
T_max=config["epochs"],
eta_min=config["min_lr"])
elif config["scheduler"] == "ReduceLROnPlateau":
scheduler = lr_scheduler(
optimizer=optimizer,
factor=config["factor"],
patience=config["patience"],
verbose=1,
min_lr=config["min_lr"],
)
elif config["scheduler"] == "MultiStepLR":
scheduler = lr_scheduler.MultiStepLR(
optimizer=optimizer,
milestones=[int(e) for e in config["milestones"].split(",")],
gamma=config["gamma"],
)
elif config["scheduler"] == "ConstantLR":
scheduler = None
else:
raise NotImplementedError
# Data loading code
if config["dataset"] == "dsb2018_96":
input_dir = cfg.DSB2018_96_DIR
img_ids = glob(
os.path.join(input_dir, "images", "*" + config["img_ext"]))
img_ids = [os.path.splitext(os.path.basename(p))[0] for p in img_ids]
train_img_ids, val_img_ids = train_test_split(img_ids,
test_size=0.2,
random_state=41)
train_transform = Compose([
transforms.RandomRotate90(),
transforms.Flip(),
OneOf(
[
transforms.HueSaturationValue(),
transforms.RandomBrightness(),
transforms.RandomContrast(),
],
p=1,
),
transforms.Resize(config["input_h"], config["input_w"]),
transforms.Normalize(),
])
val_transform = Compose([
transforms.Resize(config["input_h"], config["input_w"]),
transforms.Normalize(),
])
train_dataset = Dataset(
img_ids=train_img_ids,
img_dir=os.path.join(input_dir, "images"),
mask_dir=os.path.join(input_dir, "masks"),
img_ext=config["img_ext"],
mask_ext=config["mask_ext"],
num_classes=config["num_classes"],
transform=train_transform,
)
val_dataset = Dataset(
img_ids=val_img_ids,
img_dir=os.path.join(input_dir, "images"),
mask_dir=os.path.join(input_dir, "masks"),
img_ext=config["img_ext"],
mask_ext=config["mask_ext"],
num_classes=config["num_classes"],
transform=val_transform,
)
train_loader = torch.utils.data.DataLoader(
train_dataset,
batch_size=config["batch_size"],
shuffle=True,
num_workers=config["num_workers"],
drop_last=True,
)
val_loader = torch.utils.data.DataLoader(
val_dataset,
batch_size=config["batch_size"],
shuffle=False,
num_workers=config["num_workers"],
drop_last=False,
)
log = OrderedDict([
("epoch", []),
("lr", []),
("loss", []),
("iou", []),
("val_loss", []),
("val_iou", []),
])
best_iou = 0
trigger = 0
for epoch in range(config["epochs"] + 1):
print("Epoch [%d/%d]" % (epoch, config["epochs"]))
# train for one epoch
train_log = train(config, train_loader, model, criterion, optimizer)
# evaluate on validation set
val_log = validate(config, val_loader, model, criterion)
if config["scheduler"] == "CosineAnnealingLR":
scheduler.step()
elif config["scheduler"] == "ReduceLROnPlateau":
scheduler.step(val_log["loss"])
print("loss %.4f - iou %.4f - val_loss %.4f - val_iou %.4f" %
(train_log["loss"], train_log["iou"], val_log["loss"],
val_log["iou"]))
log["epoch"].append(epoch)
log["lr"].append(config["lr"])
log["loss"].append(train_log["loss"])
log["iou"].append(train_log["iou"])
log["val_loss"].append(val_log["loss"])
log["val_iou"].append(val_log["iou"])
# Tensorboard用のデータ
writer.add_scalar("training loss", train_log["loss"], epoch)
writer.add_scalar("validation loss", val_log["loss"], epoch)
pd.DataFrame(log).to_csv("%s/log.csv" % (log_dir), index=False)
if epoch == 0:
best_loss = val_log["loss"]
trigger += 1
# Best Model Save
# if val_log['iou'] > best_iou:
if (val_log["iou"] > best_iou) and (val_log["loss"] <= best_loss):
torch.save(model.state_dict(), "%s/model.pth" % (models_path))
best_iou = val_log["iou"]
best_loss = val_log["loss"]
print("=> saved best model")
trigger = 0
# early stopping
if (config["early_stopping"] >= 0 and
trigger >= config["early_stopping"]) or val_log["loss"] < 1e-4:
print("=> early stopping")
break
torch.cuda.empty_cache()
# summary writer を必要としない場合，close()メソッドを呼び出す
writer.close()
import pathlib
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():
fig, axs = plt.subplots(1, 3, constrained_layout=True, figsize=(20, 20))
[axs[i].set_axis_off() for i in range(3)]
# axs[0].imshow(image)
# axs[0].set_title("Original",fontsize=30)
# image_ = transforms.RandomRotate90(always_apply=True)(image=image)["image"]
# axs[1].imshow(image_)
# axs[1].set_title("Rotate",fontsize=30)
# image_ = transforms.Flip(always_apply=True)(image=image)["image"]
# axs[2].imshow(image_)
# axs[2].set_title("Flip",fontsize=30)
image_ = transforms.HueSaturationValue(always_apply=True)(image=image)["image"]
axs[0].imshow(image_)
axs[0].set_title("Saturation", fontsize=30)
image_ = transforms.RandomBrightnessContrast(always_apply=True)(
image=image)["image"]
axs[1].imshow(image_)
axs[1].set_title("Brightness", fontsize=30)
image_ = OneOf(
[
transforms.RandomCrop(204, 250, p=1),
transforms.CenterCrop(204, 250, p=1),
],
p=1,
)(image=image)["image"]
def main():
args = vars(parse_args_func())
#config_file = "../configs/config_SN7.json"
config_file = args['config'] # "../configs/config_v1.json"
config_dict = json.loads(open(config_file, 'rt').read())
#config_dict = json.loads(open(sys.argv[1], 'rt').read())
file_dict = config_dict['file_path']
config = config_dict['opt_config']
input_folder = file_dict['input_path'] # '../inputs'
checkpoint_folder = file_dict['checkpoint_path'] # '../checkpoint'
model_folder = file_dict['model_path'] # '../models'
if 'False' in config['deep_supervision']:
config['deep_supervision'] = False
else:
config['deep_supervision'] = True
if 'False' in config['nesterov']:
config['nesterov'] = False
else:
config['nesterov'] = True
if 'None' in config['name']:
config['name'] = None
if config['name'] is None:
config['name'] = '%s_%s_segmodel' % (config['dataset'], config['arch'])
os.makedirs(os.path.join(model_folder, '%s' % config['name']),
exist_ok=True)
if not os.path.isdir(checkpoint_folder):
os.mkdir(checkpoint_folder)
log_name = config['name']
log_dir = os.path.join(checkpoint_folder, log_name)
writer = SummaryWriter(logdir=log_dir)
print('-' * 20)
for key in config:
print('%s: %s' % (key, config[key]))
print('-' * 20)
with open(os.path.join(model_folder, '%s/config.yml' % config['name']),
'w') as f:
yaml.dump(config, f)
# define loss function (criterion)
if config['loss'] == 'BCEWithLogitsLoss':
criterion = nn.BCEWithLogitsLoss().cuda()
else:
criterion = losses.__dict__[config['loss']]().cuda()
cudnn.benchmark = True
# create model
print("=> creating model %s" % config['arch'])
model = archs.__dict__[config['arch']](config['num_classes'],
config['input_channels'],
config['deep_supervision'])
if 'False' in config['resume']:
config['resume'] = False
else:
config['resume'] = True
resume_flag = False
if resume_flag == True:
save_path = os.path.join(model_folder, config['name'], 'model.pth')
weights = torch.load(save_path)
model.load_state_dict(weights)
name_yaml = config['name']
with open(os.path.join(model_folder, '%s/config.yml' % name_yaml),
'r') as f:
config = yaml.load(f, Loader=yaml.FullLoader)
#start_epoch = config['epochs']
start_epoch = 0
else:
start_epoch = 0
model = model.cuda()
if 'effnet' in config['arch']:
eff_flag = True
else:
eff_flag = False
if eff_flag == True:
cnn_subs = list(model.encoder.eff_conv.children())[1:]
#cnn_params = [list(sub_module.parameters()) for sub_module in cnn_subs]
#cnn_params = [item for sublist in cnn_params for item in sublist]
summary(model,
(config['input_channels'], config['input_w'], config['input_h']))
params = filter(lambda p: p.requires_grad, model.parameters())
if eff_flag == True:
params = list(params) + list(model.encoder.conv_a.parameters())
model = torch.nn.DataParallel(model)
if config['optimizer'] == 'Adam':
optimizer = optim.Adam(params,
lr=config['lr'],
weight_decay=config['weight_decay'])
elif config['optimizer'] == 'SGD':
optimizer = optim.SGD(params,
lr=config['lr'],
momentum=config['momentum'],
nesterov=config['nesterov'],
weight_decay=config['weight_decay'])
else:
raise NotImplementedError
if eff_flag == True:
cnn_params = [list(sub_module.parameters()) for sub_module in cnn_subs]
cnn_params = [item for sublist in cnn_params for item in sublist]
cnn_optimizer = torch.optim.Adam(cnn_params,
lr=0.001,
weight_decay=config['weight_decay'])
#cnn_optimizer = None
else:
cnn_optimizer = None
if config['optimizer'] == 'SGD':
if config['scheduler'] == 'CosineAnnealingLR':
scheduler = lr_scheduler.CosineAnnealingLR(
optimizer, T_max=config['epochs'], eta_min=config['min_lr'])
elif config['scheduler'] == 'ReduceLROnPlateau':
scheduler = lr_scheduler.ReduceLROnPlateau(
optimizer,
factor=config['factor'],
patience=config['patience'],
verbose=1,
min_lr=config['min_lr'])
elif config['scheduler'] == 'MultiStepLR':
scheduler = lr_scheduler.MultiStepLR(
optimizer,
milestones=[int(e) for e in config['milestones'].split(',')],
gamma=config['gamma'])
elif config['scheduler'] == 'ConstantLR':
scheduler = None
else:
raise NotImplementedError
else:
scheduler = None
# Data loading code
img_ids = glob(
os.path.join(input_folder, config['dataset'], 'images', 'training',
'*' + config['img_ext']))
train_img_ids = [os.path.splitext(os.path.basename(p))[0] for p in img_ids]
#img_dir = os.path.join(input_folder, config['dataset'], 'images', 'training')
#mask_dir = os.path.join(input_folder, config['dataset'], 'annotations', 'training')
#train_image_mask = image_to_afile(img_dir, mask_dir, None, train_img_ids, config)
img_ids = glob(
os.path.join(input_folder, config['val_dataset'], 'images',
'validation', '*' + config['img_ext']))
val_img_ids = [os.path.splitext(os.path.basename(p))[0] for p in img_ids]
img_ids = glob(
os.path.join(input_folder, config['val_dataset'], 'images', 'test',
'*' + config['img_ext']))
test_img_ids = [os.path.splitext(os.path.basename(p))[0] for p in img_ids]
mean = [0.485, 0.456, 0.406]
std = [0.229, 0.224, 0.225]
train_transform = Compose([
#transforms.RandomScale ([config['scale_min'], config['scale_max']]),
#transforms.RandomRotate90(),
transforms.Rotate([config['rotate_min'], config['rotate_max']],
value=mean,
mask_value=0),
transforms.Flip(),
#transforms.HorizontalFlip (),
transforms.HueSaturationValue(hue_shift_limit=10,
sat_shift_limit=10,
val_shift_limit=10),
transforms.RandomBrightnessContrast(brightness_limit=0.10,
contrast_limit=0.10,
brightness_by_max=True),
transforms.Resize(config['input_h'], config['input_w']),
transforms.Normalize(mean=mean, std=std),
])
val_transform = Compose([
transforms.Resize(config['input_h'], config['input_w']),
transforms.Normalize(mean=mean, std=std),
])
train_dataset = Dataset(img_ids=train_img_ids,
img_dir=os.path.join(input_folder,
config['dataset'], 'images',
'training'),
mask_dir=os.path.join(input_folder,
config['dataset'],
'annotations', 'training'),
img_ext=config['img_ext'],
mask_ext=config['mask_ext'],
num_classes=config['num_classes'],
input_channels=config['input_channels'],
transform=train_transform,
from_file=None)
val_dataset = Dataset(img_ids=val_img_ids,
img_dir=os.path.join(input_folder,
config['val_dataset'], 'images',
'validation'),
mask_dir=os.path.join(input_folder,
config['val_dataset'],
'annotations', 'validation'),
img_ext=config['img_ext'],
mask_ext=config['mask_ext'],
num_classes=config['num_classes'],
input_channels=config['input_channels'],
transform=val_transform,
from_file=None)
test_dataset = Dataset(img_ids=test_img_ids,
img_dir=os.path.join(input_folder,
config['val_dataset'],
'images', 'test'),
mask_dir=os.path.join(input_folder,
config['val_dataset'],
'annotations', 'test'),
img_ext=config['img_ext'],
mask_ext=config['mask_ext'],
num_classes=config['num_classes'],
input_channels=config['input_channels'],
transform=val_transform,
from_file=None)
train_loader = torch.utils.data.DataLoader(
train_dataset,
batch_size=config['batch_size'],
shuffle=True,
num_workers=config['num_workers'],
drop_last=True)
val_loader = torch.utils.data.DataLoader(
val_dataset,
batch_size=1, #config['batch_size'],
shuffle=False,
num_workers=config['num_workers'],
drop_last=False)
test_loader = torch.utils.data.DataLoader(
test_dataset,
batch_size=1, #config['batch_size'],
shuffle=False,
num_workers=config['num_workers'],
drop_last=False)
log = OrderedDict([
('epoch', []),
('lr', []),
('loss', []),
('iou', []),
('dice', []),
('val_loss', []),
('val_iou', []),
('val_dice', []),
])
best_iou = 0
trigger = 0
Best_dice = 0
iou_AtBestDice = 0
for epoch in range(start_epoch, config['epochs']):
print('{:s} Epoch [{:d}/{:d}]'.format(config['arch'], epoch,
config['epochs']))
# train for one epoch
train_log = train(epoch, config, train_loader, model, criterion,
optimizer, cnn_optimizer)
if config['optimizer'] == 'SGD':
if config['scheduler'] == 'CosineAnnealingLR':
scheduler.step()
elif config['scheduler'] == 'ReduceLROnPlateau':
scheduler.step(val_log['loss'])
elif config['scheduler'] == 'MultiStepLR':
scheduler.step()
# evaluate on validation set
val_log = validate(config, val_loader, model, criterion)
test_log = validate(config, test_loader, model, criterion)
if Best_dice < test_log['dice']:
Best_dice = test_log['dice']
iou_AtBestDice = test_log['iou']
print(
'loss %.4f - iou %.4f - dice %.4f - val_loss %.4f - val_iou %.4f - val_dice %.4f - test_iou %.4f - test_dice %.4f - Best_dice %.4f - iou_AtBestDice %.4f'
% (train_log['loss'], train_log['iou'], train_log['dice'],
val_log['loss'], val_log['iou'], val_log['dice'],
test_log['iou'], test_log['dice'], Best_dice, iou_AtBestDice))
save_tensorboard(writer, train_log, val_log, test_log, epoch)
log['epoch'].append(epoch)
log['lr'].append(config['lr'])
log['loss'].append(train_log['loss'])
log['iou'].append(train_log['iou'])
log['dice'].append(train_log['dice'])
log['val_loss'].append(val_log['loss'])
log['val_iou'].append(val_log['iou'])
log['val_dice'].append(val_log['dice'])
pd.DataFrame(log).to_csv(os.path.join(model_folder,
'%s/log.csv' % config['name']),
index=False)
trigger += 1
if val_log['iou'] > best_iou:
torch.save(
model.state_dict(),
os.path.join(model_folder, '%s/model.pth' % config['name']))
best_iou = val_log['iou']
print("=> saved best model")
trigger = 0
# early stopping
if config['early_stopping'] >= 0 and trigger >= config[
'early_stopping']:
print("=> early stopping")
break
torch.cuda.empty_cache()
