def _register():
__sets['VGGnet_train'] = networks.VGG16(is_train=True)
__sets['VGGnet_test'] = networks.VGG16(is_train=False)
__sets['Resnet50_train'] = networks.Resnet50(is_train=True)
__sets['Resnet50_test'] = networks.Resnet50(is_train=False)
__sets['Resnet101_train'] = networks.Resnet101(is_train=True)
__sets['Resnet101_test'] = networks.Resnet101(is_train=False)
__sets['MobilenetV1_train'] = networks.MobilenetV1(is_train=True)
__sets['MobilenetV1_test'] = networks.MobilenetV1(is_train=False)
__sets['PVAnet_train'] = networks.PVAnet(is_train=True)
__sets['PVAnet_test'] = networks.PVAnet(is_train=False)
def _register():
__sets['VGGnet_train'] = networks.VGG16(is_train=True)
__sets['VGGnet_test'] = networks.VGG16(is_train=False)
def main():
'''
main function, start point
'''
# 引数関連
parser = argparse.ArgumentParser()
parser.add_argument('--batchsize',
'-b',
type=int,
default=128,
help='Number of images in each mini-batch')
parser.add_argument('--learnrate',
'-l',
type=float,
default=0.001,
help='Learning rate for SGD')
parser.add_argument('--epoch',
'-e',
type=int,
default=100,
help='Number of sweeps over the dataset to train')
parser.add_argument('--gpu',
'-g',
type=int,
default=0,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the training from snapshot')
parser.add_argument('--iter_parallel',
'-p',
action='store_true',
default=False,
help='filter(kernel) sizes')
parser.add_argument('--opt',
'-o',
type=str,
choices=('adam', 'sgd'),
default='adam')
args = parser.parse_args()
# parameter出力
print("-=Learning Parameter=-")
print("# Max Epochs: {}".format(args.epoch))
print("# Batch Size: {}".format(args.batchsize))
print("# Learning Rate: {}".format(args.learnrate))
print("# Optimizer Method: {}".format(args.opt))
print('# Train Dataet: General 100')
if args.iter_parallel:
print("# Data Iters that loads in Parallel")
print("\n")
# 保存ディレクトリ
# save didrectory
outdir = path.join(
ROOT_PATH,
'results/FI/AEFINet/AEFINet_ch6_fsize5_VGG_content_loss_opt_{}'.format(
args.opt))
if not path.exists(outdir):
os.makedirs(outdir)
with open(path.join(outdir, 'arg_param.txt'), 'w') as f:
for k, v in args.__dict__.items():
f.write('{}:{}\n'.format(k, v))
print('# loading dataet(General100_train, General100_test) ...')
if args.iter_parallel:
train = SequenceDataset(dataset='train')
test = SequenceDataset(dataset='test')
else:
train = SequenceDatasetOnMem(dataset='train')
test = SequenceDatasetOnMem(dataset='test')
# prepare model
vgg16 = N.VGG16()
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
vgg16.to_gpu()
chainer.serializers.load_npz(path.join(ROOT_PATH, 'models/VGG16.npz'),
vgg16)
model = N.VGG16Evaluator(N.AEFINet(ch=6, f_size=5), vgg16)
if args.gpu >= 0:
model.to_gpu()
# setup optimizer
if args.opt == 'adam':
optimizer = chainer.optimizers.Adam(alpha=args.learnrate)
elif args.opt == 'sgd':
optimizer = chainer.optimizers.MomentumSGD(lr=args.learnrate,
momentum=0.9)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.0001))
# setup iter
if args.iter_parallel:
train_iter = chainer.iterators.MultiprocessIterator(train,
args.batchsize,
n_processes=8)
test_iter = chainer.iterators.MultiprocessIterator(test,
args.batchsize,
repeat=False,
shuffle=False,
n_processes=8)
else:
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test,
args.batchsize,
repeat=False,
shuffle=False)
# setup trainer
updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=outdir)
# # eval test data
trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu))
# dump loss graph
trainer.extend(extensions.dump_graph('main/loss'))
# lr shift
if args.opt == 'sgd':
trainer.extend(extensions.ExponentialShift("lr", 0.1),
trigger=(100, 'epoch'))
if args.opt == 'adam':
trainer.extend(extensions.ExponentialShift("alpha", 0.1),
trigger=(50, 'epoch'))
# save snapshot
trainer.extend(extensions.snapshot(), trigger=(10, 'epoch'))
trainer.extend(extensions.snapshot_object(
model, 'model_snapshot_{.updater.epoch}'),
trigger=(10, 'epoch'))
# log report
trainer.extend(extensions.LogReport())
trainer.extend(extensions.observe_lr(), trigger=(1, 'epoch'))
# plot loss graph
trainer.extend(
extensions.PlotReport(['main/loss', 'validation/main/loss'],
'epoch',
file_name='loss.png'))
# plot acc graph
trainer.extend(
extensions.PlotReport(['main/PSNR', 'validation/main/PSNR'],
'epoch',
file_name='PSNR.png'))
# print info
trainer.extend(
extensions.PrintReport([
'epoch', 'main/loss', 'validation/main/loss', 'main/loss_mse',
'main/loss_cont', 'main/PSNR', 'validation/main/PSNR', 'lr',
'elapsed_time'
]))
# print progbar
trainer.extend(extensions.ProgressBar())
trainer.run()
def main():
global lossvals, best_acc1
opt = options_direct_inference.generate_parser()
start_epoch = 0
im_dim = 224
if opt.seed is not None:
random.seed(opt.seed)
torch.manual_seed(opt.seed)
cudnn.deterministic = True
model = networks.VGG16(num_classes=2, batch_norm=True)
model = model.cuda(opt.gpu)
criterion = nn.CrossEntropyLoss().cuda(opt.gpu)
optimizer = torch.optim.SGD(model.parameters(), opt.lr,
momentum=opt.momentum,
weight_decay=opt.weight_decay)
# create checkpoints folder
if not os.path.exists(opt.checkpoints_dir):
os.mkdir(opt.checkpoints_dir)
lossvals = dict()
lossvals['train'] = opt.epochs*[0]
lossvals['train_class0'] = opt.epochs * [0]
lossvals['train_class1'] = opt.epochs * [0]
lossvals['val'] = opt.epochs * [0]
lossvals['val_class0'] = opt.epochs * [0]
lossvals['val_class1'] = opt.epochs * [0]
# optionally resume from a checkpoint
if opt.resume_epoch is not None:
resume_filename = os.path.join(opt.checkpoints_dir, 'checkpoint_epoch%d.pth.tar' % opt.resume_epoch)
if os.path.isfile(resume_filename):
print("=> loading checkpoint '{}'".format(resume_filename))
checkpoint = torch.load(resume_filename, map_location=lambda storage, loc: storage.cuda(0))
print('Done with torch.load')
start_epoch = checkpoint['epoch']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
curr_lr = optimizer.param_groups[0]['lr']
#lossvals = np.load(os.path.join(opt.checkpoints_dir, 'lossvals.npy'))
print("=> loaded checkpoint '{}' (epoch {})".format(resume_filename, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(resume_filename))
cudnn.benchmark = True
normalize = transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
# Load training data
train_transform = transforms.Compose([
transforms.RandomResizedCrop(im_dim),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
])
train_dataset = data.DatasetFromMultipleFilenames(opt,
[opt.dataA_dir, opt.dataB_dir],
[opt.filenamesA, opt.filenamesB],
train_transform)
# Load validation data
val_transform = transforms.Compose([
transforms.Resize(im_dim+32),
transforms.CenterCrop(im_dim),
transforms.ToTensor(),
normalize,
])
val_dataset = data.DatasetFromMultipleFilenames(opt,
[opt.dataA_dir, opt.dataB_dir],
[opt.filenamesA_val, opt.filenamesB_val],
val_transform)
train_loader = torch.utils.data.DataLoader(
train_dataset, batch_size=opt.batch_size, shuffle=True, num_workers=opt.num_threads, pin_memory=True)
val_loader = torch.utils.data.DataLoader(
val_dataset, batch_size=opt.batch_size, shuffle=False, num_workers=opt.num_threads, pin_memory=True)
if opt.evaluate:
validate(val_loader, model, criterion, opt)
return
for epoch in range(start_epoch, opt.epochs):
adjust_learning_rate(optimizer, epoch, opt)
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch, opt)
# evaluate on validation set
acc1 = validate(val_loader, model, criterion, epoch, opt)
# remember best acc@1 and save checkpoint
is_best = acc1 > best_acc1
best_acc1 = max(acc1, best_acc1)
np.save(os.path.join(opt.checkpoints_dir, 'lossvals.npy'), lossvals)
save_checkpoint({
'epoch': epoch + 1,
'arch': opt.arch,
'state_dict': model.state_dict(),
'best_acc1': best_acc1,
'optimizer': optimizer.state_dict(),
}, is_best)