def prep_Trainer(_model,
_updater,
result_dir,
_test_iter,
cnf="./_json/configure001.json",
_args=None,
logger=None):
from chainerui.extensions import CommandsExtension
from chainerui.utils import save_args
from chainer import training
from chainer.training import extensions
trainer_cnf = read_cnf(cnf, q="Trainer")
_epoch = trainer_cnf["epoch"]
_device = trainer_cnf["device"]
_console = trainer_cnf["console"]
logger.log(_tag="Trainer", _msg="Setting accepted.")
trainer = training.Trainer(_updater, (_epoch, 'epoch'), out=result_dir)
trainer.extend(extensions.Evaluator(_test_iter, _model, device=_device))
trainer.extend(
extensions.dump_graph(root_name="main/loss", out_name="predictor.dot"))
trainer.extend(extensions.LogReport())
trainer.extend(
extensions.PlotReport(["main/loss", "validation/main/loss"],
"epoch",
file_name="loss.png"))
trainer.extend(
extensions.PlotReport(["main/accuracy", "validation/main/accuracy"],
"epoch",
file_name="accuracy.png"))
if _console:
trainer.extend(
extensions.PrintReport([
'epoch', 'main/loss', 'validation/main/loss', "main/accuracy",
"validation/main/accuracy", "elapsed_time"
]))
trainer.extend(extensions.ProgressBar(update_interval=1))
trainer.extend(extensions.observe_lr())
trainer.extend(CommandsExtension())
if _args:
save_args(args, result_dir)
return trainer
def main():
args = arguments()
# chainer.config.type_check = False
chainer.config.autotune = True
chainer.config.dtype = args.dtype
chainer.print_runtime_info()
#print('Chainer version: ', chainer.__version__)
#print('GPU availability:', chainer.cuda.available)
#print('cuDNN availability:', chainer.cuda.cudnn_enabled)
## dataset preparation
if args.imgtype == "dcm":
from dataset_dicom import Dataset
else:
from dataset import Dataset
train_d = Dataset(args.train,
args.root,
args.from_col,
args.to_col,
crop=(args.crop_height, args.crop_width),
random=args.random,
grey=args.grey)
test_d = Dataset(args.val,
args.root,
args.from_col,
args.to_col,
crop=(args.crop_height, args.crop_width),
random=args.random,
grey=args.grey)
# setup training/validation data iterators
train_iter = chainer.iterators.SerialIterator(train_d, args.batch_size)
test_iter = chainer.iterators.SerialIterator(test_d,
args.nvis,
shuffle=False)
test_iter_gt = chainer.iterators.SerialIterator(
train_d, args.nvis,
shuffle=False) ## same as training data; used for validation
args.ch = len(train_d[0][0])
args.out_ch = len(train_d[0][1])
print("Input channels {}, Output channels {}".format(args.ch, args.out_ch))
## Set up models
gen = net.Generator(args)
dis = net.Discriminator(args)
## load learnt models
optimiser_files = []
if args.model_gen:
serializers.load_npz(args.model_gen, gen)
print('model loaded: {}'.format(args.model_gen))
optimiser_files.append(args.model_gen.replace('gen_', 'opt_gen_'))
if args.model_dis:
serializers.load_npz(args.model_dis, dis)
print('model loaded: {}'.format(args.model_dis))
optimiser_files.append(args.model_dis.replace('dis_', 'opt_dis_'))
## send models to GPU
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use()
gen.to_gpu()
dis.to_gpu()
## Setup optimisers
def make_optimizer(model, alpha=0.0002, beta1=0.5):
eps = 1e-5 if args.dtype == np.float16 else 1e-8
optimizer = chainer.optimizers.Adam(alpha=alpha, beta1=beta1, eps=eps)
optimizer.setup(model)
if args.weight_decay > 0:
if args.weight_decay_norm == 'l2':
optimizer.add_hook(
chainer.optimizer.WeightDecay(args.weight_decay))
else:
optimizer.add_hook(
chainer.optimizer_hooks.Lasso(args.weight_decay))
return optimizer
opt_gen = make_optimizer(gen, alpha=args.learning_rate)
opt_dis = make_optimizer(dis, alpha=args.learning_rate)
optimizers = {'opt_g': opt_gen, 'opt_d': opt_dis}
## resume optimisers from file
if args.load_optimizer:
for (m, e) in zip(optimiser_files, optimizers):
if m:
try:
serializers.load_npz(m, optimizers[e])
print('optimiser loaded: {}'.format(m))
except:
print("couldn't load {}".format(m))
pass
# Set up trainer
updater = pixupdater(models=(gen, dis),
iterator={
'main': train_iter,
'test': test_iter,
'test_gt': test_iter_gt
},
optimizer={
'gen': opt_gen,
'dis': opt_dis
},
converter=convert.ConcatWithAsyncTransfer(),
params={'args': args},
device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
## save learnt results at an interval
if args.snapinterval < 0:
args.snapinterval = args.epoch
snapshot_interval = (args.snapinterval, 'epoch')
display_interval = (args.display_interval, 'iteration')
preview_interval = (args.vis_freq, 'iteration')
# preview_interval = (1, 'epoch')
trainer.extend(extensions.snapshot_object(gen, 'gen_{.updater.epoch}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.snapshot_object(opt_gen,
'opt_gen_{.updater.epoch}.npz'),
trigger=snapshot_interval)
trainer.extend(extensions.dump_graph('gen/loss_L1', out_name='gen.dot'))
if args.lambda_dis > 0:
trainer.extend(extensions.snapshot_object(dis,
'dis_{.updater.epoch}.npz'),
trigger=snapshot_interval)
trainer.extend(
extensions.dump_graph('dis/loss_real', out_name='dis.dot'))
trainer.extend(extensions.snapshot_object(
opt_dis, 'opt_dis_{.updater.epoch}.npz'),
trigger=snapshot_interval)
## log outputs
trainer.extend(extensions.LogReport(trigger=display_interval))
trainer.extend(extensions.PrintReport([
'epoch', 'iteration', 'gen/loss_L1', 'gen/loss_L2', 'myval/loss_L2',
'gen/loss_dis', 'gen/loss_tv', 'dis/loss_fake', 'dis/loss_real',
'dis/loss_mispair'
]),
trigger=display_interval)
if extensions.PlotReport.available():
trainer.extend(
extensions.PlotReport([
'gen/loss_L1', 'gen/loss_L2', 'gen/loss_dis', 'myval/loss_L2',
'gen/loss_tv'
],
'iteration',
trigger=display_interval,
file_name='loss_gen.png'))
trainer.extend(
extensions.PlotReport(
['dis/loss_real', 'dis/loss_fake', 'dis/loss_mispair'],
'iteration',
trigger=display_interval,
file_name='loss_dis.png'))
trainer.extend(extensions.ProgressBar(update_interval=10))
# evaluation
vis_folder = os.path.join(args.out, "vis")
os.makedirs(vis_folder, exist_ok=True)
trainer.extend(VisEvaluator({
"test": test_iter,
"train": test_iter_gt
}, {"gen": gen},
params={'vis_out': vis_folder},
device=args.gpu),
trigger=preview_interval)
# ChainerUI
trainer.extend(CommandsExtension())
# Run the training
print("trainer start")
trainer.run()
def main():
parser = argparse.ArgumentParser(description='Chainer CIFAR example:')
parser.add_argument('--seed',
'-s',
type=int,
default=0,
help='seed for random values')
parser.add_argument('--dataset',
'-d',
default='cifar10',
help='The dataset to use: cifar10 or cifar100')
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.1,
help='Learning rate for SGD')
parser.add_argument('--epoch',
'-e',
type=int,
default=300,
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('--out',
'-o',
default='result',
help='Directory to output the result')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the training from snapshot')
parser.add_argument('--aug_method',
'-a',
default='both',
choices=['none', 'mixup', 'random_erasing', 'both'],
help='data augmentation strategy')
parser.add_argument('--model',
'-m',
default='pyramid',
choices=['resnet50', 'pyramid'],
help='data augmentation strategy')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print(args)
print('')
set_random_seed(args.seed)
# Set up a neural network to train.
# Classifier reports softmax cross entropy loss and accuracy at every
# iteration, which will be used by the PrintReport extension below.
if args.dataset == 'cifar10':
print('Using CIFAR10 dataset.')
class_labels = 10
train, test = get_cifar10()
# for mean-teacher experiment
#train = train[:-10000]
#print(len(train))
elif args.dataset == 'cifar100':
print('Using CIFAR100 dataset.')
class_labels = 100
train, test = get_cifar100()
else:
raise RuntimeError('Invalid dataset choice.')
if args.model == 'resnet50':
predictor = ResNet(None)
predictor.fc6 = L.Linear(2048, class_labels)
elif args.model == 'pyramid':
predictor = shaked_pyramid_net.PyramidNet(skip=True)
# 下の方にあるtrain dataのtransformの条件分岐とかぶってるけどなー
if args.aug_method in ('both', 'mixup'):
lossfun = soft_label_classification_loss
accfun = soft_label_classification_acc
else:
lossfun = F.softmax_cross_entropy
accfun = F.accuracy
model = L.Classifier(predictor, lossfun=lossfun, accfun=accfun)
if args.gpu >= 0:
# Make a specified GPU current
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu() # Copy the model to the GPU
optimizer = chainer.optimizers.MomentumSGD(args.learnrate)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(5e-4))
# augment train data
if args.aug_method == 'none':
print('data augmentationなしです')
train = dataset.SingleCifar10((train, None))
elif args.aug_method in ('both', 'mixup'):
use_random_erasing = args.aug_method == 'both'
train = dataset.PairwiseCifar10((train, None))
train = chainer.datasets.transform_dataset.TransformDataset(
train,
transformer.MixupTransform(use_random_erasing=use_random_erasing))
elif args.aug_method == 'random_erasing':
train = dataset.SingleCifar10((train, None))
train = chainer.datasets.transform_dataset.TransformDataset(
train, transformer.RandomErasingTransform())
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test,
args.batchsize,
repeat=False,
shuffle=False)
# Set up a trainer
updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
# Evaluate the model with the test dataset for each epoch
eval_trigger = (1, 'epoch')
trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu),
trigger=eval_trigger)
# Reduce the learning rate by half every 25 epochs.
lr_drop_epoch = [int(args.epoch * 0.5), int(args.epoch * 0.75)]
lr_drop_ratio = 0.1
print(f'lr schedule: {lr_drop_ratio}, timing: {lr_drop_epoch}')
def lr_drop(trainer):
trainer.updater.get_optimizer('main').lr *= lr_drop_ratio
trainer.extend(lr_drop,
trigger=chainer.training.triggers.ManualScheduleTrigger(
lr_drop_epoch, 'epoch'))
trainer.extend(extensions.observe_lr(), trigger=(1, 'epoch'))
# Dump a computational graph from 'loss' variable at the first iteration
# The "main" refers to the target link of the "main" optimizer.
trainer.extend(extensions.dump_graph('main/loss'))
# Take a snapshot at each epoch
trainer.extend(extensions.snapshot(), trigger=(args.epoch, 'epoch'))
# Write a log of evaluation statistics for each epoch
trainer.extend(extensions.LogReport())
# Print selected entries of the log to stdout
# Here "main" refers to the target link of the "main" optimizer again, and
# "validation" refers to the default name of the Evaluator extension.
# Entries other than 'epoch' are reported by the Classifier link, called by
# either the updater or the evaluator.
trainer.extend(
extensions.PrintReport([
'epoch', 'lr', 'main/loss', 'validation/main/loss',
'main/accuracy', 'validation/main/accuracy', 'elapsed_time'
]))
# Print a progress bar to stdout
trainer.extend(extensions.ProgressBar())
# interact with chainerui
trainer.extend(CommandsExtension(), trigger=(100, 'iteration'))
# save args
save_args(args, args.out)
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
def main():
args = arguments()
chainer.config.autotune = True
chainer.print_runtime_info()
print(args)
if args.dp:
from net_dp import Encoder, Decoder
else:
from net import Encoder, Decoder
if args.gpu >= 0:
cuda.get_device(args.gpu).use()
xp = cuda.cupy
sp = cupyx.scipy.sparse
else:
print("runs desperately slowly without a GPU!")
xp = np
sp = scipy.sparse
## Input information ##
# InputFile = scanconf.ScanConfig()
# InputFile.reconSize = args.crop_width
## setup trainable links
decoder = Decoder(args)
if args.use_enc:
encoder = Encoder(args)
else:
encoder = L.Linear(1)
if args.use_dis:
dis = Discriminator(args)
else:
dis = L.Linear(1)
if args.model_dis:
serializers.load_npz(args.model_dis, dis)
print('discriminator model loaded: {}'.format(args.model_dis))
if args.model_gen:
if 'enc' in args.model_gen and not args.decoder_only:
serializers.load_npz(args.model_gen, encoder)
print('encoder model loaded: {}'.format(args.model_gen))
serializers.load_npz(args.model_gen.replace('enc', 'dec'), decoder)
print('decoder model loaded: {}'.format(
args.model_gen.replace('enc', 'dec')))
if args.lambda_sd > 0 and args.lr_sd < 0.05:
print(
"\n\n for usual iterative reconstruction (-ls), --lr_sd should be around 0.1. \n\n"
)
if args.latent_dim > 0:
init = xp.zeros((args.batchsize, args.latent_dim)).astype(np.float32)
elif args.decoder_only:
init = xp.zeros((args.batchsize, decoder.latent_c, decoder.latent_h,
decoder.latent_w)).astype(np.float32)
else:
init = xp.zeros((args.batchsize, 1, args.crop_height,
args.crop_width)).astype(np.float32)
# init = xp.random.uniform(-0.1,0.1,(1,1,args.crop_height,args.crop_width)).astype(np.float32)
print("Initial image {} shape {}".format(args.model_image, init.shape))
seed = L.Parameter(init)
if args.gpu >= 0:
decoder.to_gpu()
seed.to_gpu()
encoder.to_gpu()
dis.to_gpu()
# setup optimisers
def make_optimizer(model, lr, opttype='Adam'):
# eps = 1e-5 if args.dtype==np.float16 else 1e-8
optimizer = optim[opttype](lr)
#from profiled_optimizer import create_marked_profile_optimizer
# optimizer = create_marked_profile_optimizer(optim[opttype](lr), sync=True, sync_level=2)
optimizer.setup(model)
if args.weight_decay > 0:
if opttype in ['Adam', 'Adam_d', 'AdaBound', 'Eve']:
optimizer.weight_decay_rate = args.weight_decay
else:
optimizer.add_hook(
chainer.optimizer_hooks.WeightDecay(args.weight_decay))
# optimizer.add_hook(chainer.optimizer_hooks.GradientClipping(100))
return optimizer
optimizer_sd = make_optimizer(seed, args.lr_sd, args.optimizer)
optimizer_dec = make_optimizer(decoder, args.lr_gen, args.optimizer)
optimizer_enc = make_optimizer(encoder, args.lr_gen, args.optimizer)
optimizer_dis = make_optimizer(dis, args.lr_dis, args.optimizer_dis)
# unify CPU and GPU memory to load big matrices
if args.unified_memory_pool and args.crop_height > 256:
pool = cp.cuda.MemoryPool(cp.cuda.malloc_managed)
cp.cuda.set_allocator(pool.malloc)
# projection matrices
prMats, conjMats = None, None
if args.lambda_sd > 0 or args.lambda_nn > 0:
prMat = scipy.sparse.load_npz(
os.path.join(args.root, args.projection_matrix)).tocsr(copy=False)
# cx = prMat.tocsr()
# rows,cols = cx.nonzero()
# for i,j in zip(rows,cols):
# if cx[i,j] < 1e-5:
# cx[i,j] = 0
# prMat = cx.tocoo()
# scipy.sparse.save_npz("d:/ml/reconst/pr.npz",prMat)
prMats = [
sp.coo_matrix((prMat[np.arange(i, prMat.shape[0], args.osem), :]),
dtype=np.float32) for i in range(args.osem)
]
prMats = [
chainer.utils.CooMatrix(p.data, p.row, p.col, p.shape)
for p in prMats
]
print("Projection matrix {} shape {}, thinned {} x {}".format(
args.projection_matrix, prMat.shape, prMats[0].shape, len(prMats)))
if args.system_matrix:
conjMat = scipy.sparse.load_npz(
os.path.join(args.root, args.system_matrix)).tocsr(copy=False)
conjMats = [
sp.coo_matrix(
(conjMat[np.arange(i, conjMat.shape[0], args.osem), :]),
dtype=np.float32) for i in range(args.osem)
]
conjMats = [
chainer.utils.CooMatrix(p.data, p.row, p.col, p.shape)
for p in conjMats
]
# conjMat = sp.coo_matrix(conjMat, dtype = np.float32)
# conjMat = chainer.utils.CooMatrix(conjMat.data, conjMat.row, conjMat.col, conjMat.shape)
print("Conjugate matrix {} shape {}, thinned {} x {}".format(
args.system_matrix, conjMat.shape, conjMats[0].shape,
len(conjMats)))
# setup updater
print("Setting up data iterators...")
planct_dataset = Dataset(path=args.planct_dir,
baseA=args.HU_base,
rangeA=args.HU_range,
crop=(args.crop_height, args.crop_width),
scale_to=args.scale_to,
random=args.random_translate)
planct_iter = chainer.iterators.SerialIterator(planct_dataset,
args.batchsize,
shuffle=True)
mvct_dataset = Dataset(path=args.mvct_dir,
baseA=args.HU_base,
rangeA=args.HU_range,
crop=(args.crop_height, args.crop_width),
scale_to=args.scale_to,
random=args.random_translate)
mvct_iter = chainer.iterators.SerialIterator(mvct_dataset,
args.batchsize,
shuffle=True)
data = prjData(args.sinogram, osem=args.osem)
proj_iter = chainer.iterators.SerialIterator(data,
args.batchsize,
shuffle=False) # True
updater = Updater(models=(seed, encoder, decoder, dis),
iterator={
'main': proj_iter,
'planct': planct_iter,
'mvct': mvct_iter
},
optimizer={
'main': optimizer_sd,
'enc': optimizer_enc,
'dec': optimizer_dec,
'dis': optimizer_dis
},
device=args.gpu,
params={
'args': args,
'prMats': prMats,
'conjMats': conjMats
})
# logging
if args.epoch < 0:
total_iter = -args.epoch * args.iter * math.ceil(
len(data) / args.batchsize)
else:
total_iter = args.epoch * args.iter
trainer = training.Trainer(updater, (total_iter, 'iteration'),
out=args.out)
log_interval = (50, 'iteration')
log_keys_main = []
log_keys_dis = []
log_keys_grad = [
'main/grad_sd', 'main/grad_gen', 'main/grad_sd_consistency',
'main/grad_gen_consistency', 'main/seed_diff'
]
loss_main_list = [(args.lambda_sd, 'main/loss_sd'),
(args.lambda_nn, 'main/loss_nn'),
(args.lambda_ae1, 'main/loss_ae1'),
(args.lambda_ae2, 'main/loss_ae2'),
(args.lambda_tv, 'main/loss_tv'),
(args.lambda_tvs, 'main/loss_tvs'),
(args.lambda_reg, 'main/loss_reg'),
(args.lambda_reg, 'main/loss_reg_ae')]
for a, k in loss_main_list:
if a > 0:
log_keys_main.append(k)
loss_dis_list = [(args.lambda_adv, 'main/loss_adv'),
(args.lambda_advs, 'main/loss_advs'),
(args.dis_freq, 'main/loss_dis'),
(args.lambda_gan, 'main/loss_gan')]
for a, k in loss_dis_list:
if a > 0:
log_keys_dis.append(k)
log_keys = ['iteration'] + log_keys_main + log_keys_dis + log_keys_grad
trainer.extend(extensions.observe_lr(), trigger=log_interval)
trainer.extend(extensions.LogReport(keys=log_keys, trigger=log_interval))
trainer.extend(extensions.PrintReport(log_keys), trigger=log_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
if extensions.PlotReport.available():
trainer.extend(
extensions.PlotReport(log_keys_main,
'iteration',
trigger=(100, 'iteration'),
file_name='loss.png',
postprocess=plot_log))
trainer.extend(
extensions.PlotReport(log_keys_dis,
'iteration',
trigger=(100, 'iteration'),
file_name='loss_dis.png'))
trainer.extend(
extensions.PlotReport(log_keys_grad,
'iteration',
trigger=(100, 'iteration'),
file_name='loss_grad.png',
postprocess=plot_log))
# trainer.extend(extensions.ParameterStatistics([seed,decoder])) ## very slow
trainer.extend(CommandsExtension())
if args.snapinterval <= 0:
args.snapinterval = total_iter
if args.lambda_nn > 0:
trainer.extend(
extensions.dump_graph('main/loss_nn', out_name='gen.dot'))
elif args.lambda_ae1 > 0:
trainer.extend(
extensions.dump_graph('main/loss_ae1', out_name='gen.dot'))
# save models
if args.use_enc:
trainer.extend(extensions.snapshot_object(
encoder, 'enc_{.updater.iteration}.npz'),
trigger=(args.snapinterval, 'iteration'))
trainer.extend(extensions.snapshot_object(
optimizer_enc, 'opt_enc_{.updater.iteration}.npz'),
trigger=(args.snapinterval, 'iteration'))
if args.use_dis:
trainer.extend(extensions.snapshot_object(
dis, 'dis_{.updater.iteration}.npz'),
trigger=(args.snapinterval, 'iteration'))
trainer.extend(extensions.snapshot_object(
optimizer_dis, 'opt_dis_{.updater.iteration}.npz'),
trigger=(args.snapinterval, 'iteration'))
# trainer.extend(extensions.dump_graph('main/loss_real', out_name='dis.dot'))
trainer.extend(extensions.snapshot_object(decoder,
'dec_{.updater.iteration}.npz'),
trigger=(args.snapinterval, 'iteration'))
trainer.extend(extensions.snapshot_object(
optimizer_dec, 'opt_dec_{.updater.iteration}.npz'),
trigger=(args.snapinterval, 'iteration'))
# save command line arguments
os.makedirs(args.out, exist_ok=True)
save_args(args, args.out)
with open(os.path.join(args.out, "args.txt"), 'w') as fh:
fh.write(" ".join(sys.argv))
trainer.run()
def main():
parser = argparse.ArgumentParser(description='Chainer CIFAR example:')
parser.add_argument('--seed',
'-s',
type=int,
default=0,
help='seed for random values')
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.1,
help='Learning rate for SGD')
parser.add_argument('--epoch',
'-e',
type=int,
default=300,
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('--out',
'-o',
default='result',
help='Directory to output the result')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the training from snapshot')
parser.add_argument('--weight',
'-w',
default='',
help='load pretrained model')
parser.add_argument('--decay', default=5e-4, type=float)
parser.add_argument('--data_dir', default='data/train')
parser.add_argument('--print_interval',
default=1000,
type=int,
help='print interval(iteration)')
parser.add_argument('--margin',
default=0.2,
type=float,
help='triplet margin')
parser.add_argument('--activate_function',
choices=['None', 'sigmoid', 'normalize'],
default='None',
help='activate function of last layer')
parser.add_argument('--init_scale',
default=0.01,
type=float,
help='FC層の初期乱数重みを決めるLeCunNormalにかけるスケール')
parser.add_argument(
'--grad_clip',
type=float,
help='勾配の上限、activate functionがNoneでこれも設定しないと、一瞬で学習が爆発する')
parser.add_argument('--after', type=int, help='プロセスの終了を待つ')
parser.add_argument('--dropout_ratio',
type=float,
default=0.5,
help='FC層のDropout.使いたくないときは0.0にする')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print(args)
print('')
if args.after:
wait_process(args.after)
# https://twitter.com/mitmul/status/960155585768439808
set_random_seed(args.seed)
# model = siamese_network.create_model(activate=None)
if args.activate_function == 'None':
activation_function = None
elif args.activate_function == 'sigmoid':
activation_function = F.sigmoid
elif args.activate_function == 'normalize':
activation_function = F.normalize
model = siamese_network.SiameseNet(activate=activation_function,
init_scale=args.init_scale,
dropout_ratio=args.dropout_ratio)
if not args.weight == '':
chainer.serializers.load_npz(args.weight, model, path='model/')
print('number of parameters:{}'.format(model.count_params()))
model = siamese_network.SiameseNetTrainChain(model, margin=args.margin)
if args.gpu >= 0:
# Make a specified GPU current
chainer.backends.cuda.get_device_from_id(args.gpu).use()
model.to_gpu() # Copy the model to the GPU
optimizer = chainer.optimizers.MomentumSGD(args.learnrate)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(args.decay))
if args.grad_clip:
print('use gradient clip:{}'.format(args.grad_clip))
optimizer.add_hook(
chainer.optimizer_hooks.GradientClipping(args.grad_clip))
# augment train data
default_value = np.zeros((3, 224, 224), dtype=np.float32), np.zeros(
(3, 224, 224), dtype=np.float32), np.ones((3, 224, 224),
dtype=np.float32)
train = triplet_dataset.TripletDataset(join(args.data_dir,
'train_triplet.txt'),
root=args.data_dir,
dtype=np.uint8)
train = skip_transform.SkipTransform(train, NoTransform(), default_value)
train_iter = chainer.iterators.MultiprocessIterator(train,
args.batchsize,
shared_mem=100000000)
test = triplet_dataset.TripletDataset(join(args.data_dir,
'test_triplet.txt'),
root=args.data_dir,
dtype=np.uint8)
test = skip_transform.SkipTransform(test, NoTransform(), default_value)
test_iter = chainer.iterators.SerialIterator(test,
args.batchsize,
repeat=False,
shuffle=False)
# Set up a trainer
updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
# trainer = training.Trainer(
# updater, (5, 'iteration'), out=args.out)
# Evaluate the model with the test dataset for each epoch
eval_trigger = (1, 'epoch')
trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu),
trigger=eval_trigger)
# Reduce the learning rate by half every 25 epochs.
lr_drop_epoch = [int(args.epoch * 0.5), int(args.epoch * 0.75)]
lr_drop_ratio = 0.1
print('lr schedule: {}, timing: {}'.format(lr_drop_ratio, lr_drop_epoch))
def lr_drop(trainer):
trainer.updater.get_optimizer('main').lr *= lr_drop_ratio
trainer.extend(lr_drop,
trigger=chainer.training.triggers.ManualScheduleTrigger(
lr_drop_epoch, 'epoch'))
trainer.extend(extensions.observe_lr(), trigger=(1, 'epoch'))
# Dump a computational graph from 'loss' variable at the first iteration
# The "main" refers to the target link of the "main" optimizer.
# trainer.extend(extensions.dump_graph('main/loss'))
# Take a snapshot at each epoch
trainer.extend(extensions.snapshot(), trigger=(args.epoch, 'epoch'))
trainer.extend(extensions.snapshot_object(model, 'best_accuracy.npz'),
trigger=chainer.training.triggers.MaxValueTrigger(
'validation/main/loss'))
trainer.extend(extensions.snapshot_object(
model, 'model_{.updater.iteration}.npz'),
trigger=(5000, 'iteration'))
# Write a log of evaluation statistics for each epoch
trainer.extend(
extensions.LogReport(trigger=(args.print_interval, 'iteration')))
# Print selected entries of the log to stdout
# Here "main" refers to the target link of the "main" optimizer again, and
# "validation" refers to the default name of the Evaluator extension.
# Entries other than 'epoch' are reported by the Classifier link, called by
# either the updater or the evaluator.
trainer.extend(extensions.PrintReport([
'epoch', 'lr', 'main/loss', 'validation/main/loss', 'main/accuracy',
'validation/main/accuracy', 'elapsed_time'
]),
trigger=(args.print_interval, 'iteration'))
# Print a progress bar to stdout
trainer.extend(extensions.ProgressBar())
# interact with chainerui
trainer.extend(CommandsExtension(), trigger=(100, 'iteration'))
# save args
save_args(args, args.out)
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
def main():
parser = argparse.ArgumentParser(description='Mask R-CNN')
parser.add_argument('--gpu', '-g', type=int, default=0)
parser.add_argument('--lr', '-l', type=float, default=1e-3)
parser.add_argument('--out',
'-o',
default='result',
help='Output directory')
parser.add_argument('--iteration', '-i', type=int, default=200000)
parser.add_argument('--weight', '-w', type=str, default='')
parser.add_argument('--label_file',
'-f',
type=str,
default='data/label_coco.txt')
parser.add_argument('--backbone', type=str, default='fpn')
parser.add_argument('--head_arch', '-a', type=str, default='fpn_keypoint')
parser.add_argument('--multi_gpu', '-m', type=int, default=0)
parser.add_argument('--batch_size', '-b', type=int, default=1)
parser.add_argument('--dataset', default='coco', choices=['coco', 'depth'])
args = parser.parse_args()
print('lr:{}'.format(args.lr))
print('output:{}'.format(args.out))
print('weight:{}'.format(args.weight))
print('label file:{}'.format(args.label_file))
print('iteration::{}'.format(args.iteration))
print('backbone architecture:{}'.format(args.backbone))
print('head architecture:{}'.format(args.head_arch))
if args.dataset == 'coco':
train_data = load_dataset(COCOKeypointsLoader, 'train_data_kp.pkl')
elif args.dataset == 'depth':
train_data = load_dataset(
lambda: DepthDataset(path='data/rgbd/train.txt', root='data/rgbd/'
), 'train_data_depth_kp.pkl')
n_keypoints = train_data.n_keypoints
print(f'number of keypoints={n_keypoints}')
if args.multi_gpu:
print(
'try to use chainer.training.updaters.MultiprocessParallelUpdater')
if not chainer.training.updaters.MultiprocessParallelUpdater.available(
):
print('MultiprocessParallelUpdater is not available')
args.multi_gpu = 0
faster_rcnn = MaskRCNNResnet50(n_fg_class=1,
backbone=args.backbone,
head_arch=args.head_arch,
n_keypoints=n_keypoints)
faster_rcnn.use_preset('evaluate')
model = FPNMaskRCNNTrainChain(
faster_rcnn,
mask_loss_fun=lambda x, y, z, w: calc_mask_loss(
x, y, z, w, num_keypoints=n_keypoints),
binary_mask=False)
if exists(args.weight):
chainer.serializers.load_npz(args.weight,
model.faster_rcnn,
strict=False)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
optimizer = chainer.optimizers.MomentumSGD(lr=args.lr, momentum=0.9)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(rate=0.0005))
# TransformでFaster-RCNNのprepareを参照するので、初期化順が複雑に入り組んでしまったなー
train_data = TransformDataset(train_data, Transform(faster_rcnn))
if args.multi_gpu:
train_iters = [
chainer.iterators.SerialIterator(train_data,
1,
repeat=True,
shuffle=True) for i in range(8)
]
updater = chainer.training.updater.MultiprocessParallelUpdater(
train_iters, optimizer, device=range(8))
else:
train_iter = chainer.iterators.SerialIterator(
train_data, batch_size=args.batch_size, repeat=True, shuffle=False)
updater = chainer.training.updater.StandardUpdater(train_iter,
optimizer,
device=args.gpu)
trainer = chainer.training.Trainer(updater, (args.iteration, 'iteration'),
args.out)
trainer.extend(extensions.snapshot_object(
model.faster_rcnn, 'model_{.updater.iteration}.npz'),
trigger=(20000, 'iteration'))
trainer.extend(extensions.ExponentialShift('lr', 0.1),
trigger=(1, 'epoch'))
log_interval = 100, 'iteration'
trainer.extend(chainer.training.extensions.observe_lr(),
trigger=log_interval)
trainer.extend(extensions.LogReport(trigger=log_interval))
trainer.extend(extensions.PrintReport([
'iteration',
'epoch',
'elapsed_time',
'lr',
'main/loss',
'main/mask_loss',
'main/roi_loc_loss',
'main/roi_cls_loss',
'main/rpn_loc_loss',
'main/rpn_cls_loss',
]),
trigger=(100, 'iteration'))
trainer.extend(extensions.ProgressBar(update_interval=200))
trainer.extend(extensions.dump_graph('main/loss'))
save_args(args, args.out)
trainer.extend(CommandsExtension(), trigger=(100, 'iteration'))
trainer.run()
def main():
args = arguments()
outdir = os.path.join(args.out, dt.now().strftime('%m%d_%H%M') + "_cgan")
# chainer.config.type_check = False
chainer.config.autotune = True
chainer.config.dtype = dtypes[args.dtype]
chainer.print_runtime_info()
#print('Chainer version: ', chainer.__version__)
#print('GPU availability:', chainer.cuda.available)
#print('cuDNN availability:', chainer.cuda.cudnn_enabled)
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use()
## dataset preparation
train_d = Dataset(args.train,
args.root,
args.from_col,
args.to_col,
clipA=args.clipA,
clipB=args.clipB,
class_num=args.class_num,
crop=(args.crop_height, args.crop_width),
imgtype=args.imgtype,
random=args.random_translate,
grey=args.grey,
BtoA=args.btoa)
test_d = Dataset(args.val,
args.root,
args.from_col,
args.to_col,
clipA=args.clipA,
clipB=args.clipB,
class_num=args.class_num,
crop=(args.crop_height, args.crop_width),
imgtype=args.imgtype,
random=args.random_translate,
grey=args.grey,
BtoA=args.btoa)
args.crop_height, args.crop_width = train_d.crop
if (len(train_d) == 0):
print("No images found!")
exit()
# setup training/validation data iterators
train_iter = chainer.iterators.SerialIterator(train_d, args.batch_size)
test_iter = chainer.iterators.SerialIterator(test_d,
args.nvis,
shuffle=False)
test_iter_gt = chainer.iterators.SerialIterator(
train_d, args.nvis,
shuffle=False) ## same as training data; used for validation
args.ch = len(train_d[0][0])
args.out_ch = len(train_d[0][1])
print("Input channels {}, Output channels {}".format(args.ch, args.out_ch))
if (len(train_d) * len(test_d) == 0):
print("No images found!")
exit()
## Set up models
# shared pretrained layer
if (args.gen_pretrained_encoder and args.gen_pretrained_lr_ratio == 0):
if "resnet" in args.gen_pretrained_encoder:
pretrained = L.ResNet50Layers()
print("Pretrained ResNet model loaded.")
else:
pretrained = L.VGG16Layers()
print("Pretrained VGG model loaded.")
if args.gpu >= 0:
pretrained.to_gpu()
enc_x = net.Encoder(args, pretrained)
else:
enc_x = net.Encoder(args)
# gen = net.Generator(args)
dec_y = net.Decoder(args)
if args.lambda_dis > 0:
dis = net.Discriminator(args)
models = {'enc_x': enc_x, 'dec_y': dec_y, 'dis': dis}
else:
dis = L.Linear(1, 1)
models = {'enc_x': enc_x, 'dec_y': dec_y}
## load learnt models
optimiser_files = []
if args.model_gen:
serializers.load_npz(args.model_gen, enc_x)
serializers.load_npz(args.model_gen.replace('enc_x', 'dec_y'), dec_y)
print('model loaded: {}, {}'.format(
args.model_gen, args.model_gen.replace('enc_x', 'dec_y')))
optimiser_files.append(args.model_gen.replace('enc_x', 'opt_enc_x'))
optimiser_files.append(args.model_gen.replace('enc_x', 'opt_dec_y'))
if args.model_dis:
serializers.load_npz(args.model_dis, dis)
print('model loaded: {}'.format(args.model_dis))
optimiser_files.append(args.model_dis.replace('dis', 'opt_dis'))
## send models to GPU
if args.gpu >= 0:
enc_x.to_gpu()
dec_y.to_gpu()
dis.to_gpu()
# Setup optimisers
def make_optimizer(model, lr, opttype='Adam', pretrained_lr_ratio=1.0):
# eps = 1e-5 if args.dtype==np.float16 else 1e-8
optimizer = optim[opttype](lr)
optimizer.setup(model)
if args.weight_decay > 0:
if opttype in ['Adam', 'AdaBound', 'Eve']:
optimizer.weight_decay_rate = args.weight_decay
else:
if args.weight_decay_norm == 'l2':
optimizer.add_hook(
chainer.optimizer.WeightDecay(args.weight_decay))
else:
optimizer.add_hook(
chainer.optimizer_hooks.Lasso(args.weight_decay))
return optimizer
opt_enc_x = make_optimizer(enc_x, args.learning_rate_gen, args.optimizer)
opt_dec_y = make_optimizer(dec_y, args.learning_rate_gen, args.optimizer)
opt_dis = make_optimizer(dis, args.learning_rate_dis, args.optimizer)
optimizers = {'enc_x': opt_enc_x, 'dec_y': opt_dec_y, 'dis': opt_dis}
## resume optimisers from file
if args.load_optimizer:
for (m, e) in zip(optimiser_files, optimizers):
if m:
try:
serializers.load_npz(m, optimizers[e])
print('optimiser loaded: {}'.format(m))
except:
print("couldn't load {}".format(m))
pass
# finetuning
if args.gen_pretrained_encoder:
if args.gen_pretrained_lr_ratio == 0:
enc_x.base.disable_update()
else:
for func_name in enc_x.encoder.base._children:
for param in enc_x.encoder.base[func_name].params():
param.update_rule.hyperparam.eta *= args.gen_pretrained_lr_ratio
# Set up trainer
updater = Updater(
models=(enc_x, dec_y, dis),
iterator={'main': train_iter},
optimizer=optimizers,
# converter=convert.ConcatWithAsyncTransfer(),
params={'args': args},
device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=outdir)
## save learnt results at a specified interval or at the end of training
if args.snapinterval < 0:
args.snapinterval = args.epoch
snapshot_interval = (args.snapinterval, 'epoch')
display_interval = (args.display_interval, 'iteration')
for e in models:
trainer.extend(extensions.snapshot_object(models[e],
e + '{.updater.epoch}.npz'),
trigger=snapshot_interval)
if args.parameter_statistics:
trainer.extend(extensions.ParameterStatistics(
models[e])) ## very slow
for e in optimizers:
trainer.extend(extensions.snapshot_object(
optimizers[e], 'opt_' + e + '{.updater.epoch}.npz'),
trigger=snapshot_interval)
## plot NN graph
if args.lambda_rec_l1 > 0:
trainer.extend(
extensions.dump_graph('dec_y/loss_L1', out_name='enc.dot'))
elif args.lambda_rec_l2 > 0:
trainer.extend(
extensions.dump_graph('dec_y/loss_L2', out_name='gen.dot'))
elif args.lambda_rec_ce > 0:
trainer.extend(
extensions.dump_graph('dec_y/loss_CE', out_name='gen.dot'))
if args.lambda_dis > 0:
trainer.extend(
extensions.dump_graph('dis/loss_real', out_name='dis.dot'))
## log outputs
log_keys = ['epoch', 'iteration', 'lr']
log_keys_gen = ['myval/loss_L1', 'myval/loss_L2']
log_keys_dis = []
if args.lambda_rec_l1 > 0:
log_keys_gen.append('dec_y/loss_L1')
if args.lambda_rec_l2 > 0:
log_keys_gen.append('dec_y/loss_L2')
if args.lambda_rec_ce > 0:
log_keys_gen.extend(['dec_y/loss_CE', 'myval/loss_CE'])
if args.lambda_reg > 0:
log_keys.extend(['enc_x/loss_reg'])
if args.lambda_tv > 0:
log_keys_gen.append('dec_y/loss_tv')
if args.lambda_dis > 0:
log_keys_dis.extend(
['dec_y/loss_dis', 'dis/loss_real', 'dis/loss_fake'])
if args.lambda_mispair > 0:
log_keys_dis.append('dis/loss_mispair')
if args.dis_wgan:
log_keys_dis.extend(['dis/loss_gp'])
trainer.extend(extensions.LogReport(trigger=display_interval))
trainer.extend(extensions.PrintReport(log_keys + log_keys_gen +
log_keys_dis),
trigger=display_interval)
if extensions.PlotReport.available():
# trainer.extend(extensions.PlotReport(['lr'], 'iteration',trigger=display_interval, file_name='lr.png'))
trainer.extend(
extensions.PlotReport(log_keys_gen,
'iteration',
trigger=display_interval,
file_name='loss_gen.png',
postprocess=plot_log))
trainer.extend(
extensions.PlotReport(log_keys_dis,
'iteration',
trigger=display_interval,
file_name='loss_dis.png'))
trainer.extend(extensions.ProgressBar(update_interval=10))
# learning rate scheduling
trainer.extend(extensions.observe_lr(optimizer_name='enc_x'),
trigger=display_interval)
if args.optimizer in ['Adam', 'AdaBound', 'Eve']:
lr_target = 'eta'
else:
lr_target = 'lr'
if args.lr_drop > 0: ## cosine annealing
for e in [opt_enc_x, opt_dec_y, opt_dis]:
trainer.extend(CosineShift(lr_target,
args.epoch // args.lr_drop,
optimizer=e),
trigger=(1, 'epoch'))
else:
for e in [opt_enc_x, opt_dec_y, opt_dis]:
#trainer.extend(extensions.LinearShift('eta', (1.0,0.0), (decay_start_iter,decay_end_iter), optimizer=e))
trainer.extend(extensions.ExponentialShift('lr', 0.33,
optimizer=e),
trigger=(args.epoch // args.lr_drop, 'epoch'))
# evaluation
vis_folder = os.path.join(outdir, "vis")
os.makedirs(vis_folder, exist_ok=True)
if not args.vis_freq:
args.vis_freq = max(len(train_d) // 2, 50)
trainer.extend(VisEvaluator({
"test": test_iter,
"train": test_iter_gt
}, {
"enc_x": enc_x,
"dec_y": dec_y
},
params={
'vis_out': vis_folder,
'args': args
},
device=args.gpu),
trigger=(args.vis_freq, 'iteration'))
# ChainerUI: removed until ChainerUI updates to be compatible with Chainer 6.0
trainer.extend(CommandsExtension())
# Run the training
print("\nresults are saved under: ", outdir)
save_args(args, outdir)
trainer.run()
def main():
parser = argparse.ArgumentParser(description='Chainer CIFAR example:')
parser.add_argument('--seed',
'-s',
type=int,
default=0,
help='seed for random values')
# parser.add_argument('--dataset', '-d', default='cifar10',
# help='The dataset to use: cifar10 or cifar100')
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.1,
help='Learning rate for SGD')
parser.add_argument('--epoch',
'-e',
type=int,
default=300,
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('--out',
'-o',
default='result',
help='Directory to output the result')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the training from snapshot')
parser.add_argument('--aug_method',
'-a',
default='random_erasing',
choices=['none', 'mixup', 'random_erasing', 'both'],
help='data augmentation strategy')
parser.add_argument('--model',
'-m',
default='pyramid',
choices=['resnet50', 'pyramid'],
help='data augmentation strategy')
parser.add_argument('--weight',
'-w',
default='',
help='load pretrained model')
parser.add_argument('--start_channel',
default=16,
type=int,
help='start channel')
parser.add_argument('--depth', default=16, type=int, help='depth')
parser.add_argument('--alpha', default=90, type=int, help='alpha')
parser.add_argument('--decay', default=5e-4, type=float)
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print(args)
print('')
# https://twitter.com/mitmul/status/960155585768439808
set_random_seed(args.seed)
class_labels = 55
if args.model == 'resnet50':
predictor = ResNet('auto')
predictor.fc6 = L.Linear(2048, class_labels)
elif args.model == 'pyramid':
predictor = shaked_pyramid_net.PyramidNet(
skip=True,
num_class=class_labels,
depth=args.depth,
alpha=args.alpha,
start_channel=args.start_channel)
model = L.Classifier(predictor)
if not args.weight == '':
chainer.serializers.load_npz(args.weight, model)
if args.gpu >= 0:
# Make a specified GPU current
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu() # Copy the model to the GPU
optimizer = chainer.optimizers.MomentumSGD(args.learnrate)
#optimizer = chainer.optimizers.Adam()
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(args.decay))
# augment train data
train = chainer.datasets.LabeledImageDataset('../train.txt',
root='../',
dtype=np.uint8)
train = chainer.datasets.transform_dataset.TransformDataset(
train, augmentor_transformer.AugmentorTransform())
train_iter = chainer.iterators.MultiprocessIterator(train, args.batchsize)
test = chainer.datasets.LabeledImageDataset('../test.txt',
root='../',
dtype=np.uint8)
test = chainer.datasets.transform_dataset.TransformDataset(
test, augmentor_transformer.AugmentorTransform(train=False))
test_iter = chainer.iterators.SerialIterator(test,
args.batchsize,
repeat=False,
shuffle=False)
# Set up a trainer
updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
# Evaluate the model with the test dataset for each epoch
eval_trigger = (1, 'epoch')
trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu),
trigger=eval_trigger)
# Reduce the learning rate by half every 25 epochs.
lr_drop_epoch = [int(args.epoch * 0.5), int(args.epoch * 0.75)]
lr_drop_ratio = 0.1
print(f'lr schedule: {lr_drop_ratio}, timing: {lr_drop_epoch}')
def lr_drop(trainer):
trainer.updater.get_optimizer('main').lr *= lr_drop_ratio
trainer.extend(lr_drop,
trigger=chainer.training.triggers.ManualScheduleTrigger(
lr_drop_epoch, 'epoch'))
trainer.extend(extensions.observe_lr(), trigger=(1, 'epoch'))
# Dump a computational graph from 'loss' variable at the first iteration
# The "main" refers to the target link of the "main" optimizer.
trainer.extend(extensions.dump_graph('main/loss'))
# Take a snapshot at each epoch
trainer.extend(extensions.snapshot(), trigger=(args.epoch, 'epoch'))
trainer.extend(extensions.snapshot_object(model, 'best_accuracy.npz'),
trigger=chainer.training.triggers.MaxValueTrigger(
'validation/main/accuracy'))
# Write a log of evaluation statistics for each epoch
trainer.extend(extensions.LogReport())
# Print selected entries of the log to stdout
# Here "main" refers to the target link of the "main" optimizer again, and
# "validation" refers to the default name of the Evaluator extension.
# Entries other than 'epoch' are reported by the Classifier link, called by
# either the updater or the evaluator.
trainer.extend(
extensions.PrintReport([
'epoch', 'lr', 'main/loss', 'validation/main/loss',
'main/accuracy', 'validation/main/accuracy', 'elapsed_time'
]))
# Print a progress bar to stdout
trainer.extend(extensions.ProgressBar())
# interact with chainerui
trainer.extend(CommandsExtension(), trigger=(100, 'iteration'))
# save args
save_args(args, args.out)
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
def main():
"""
main関数
"""
parser = argparse.ArgumentParser()
parser.add_argument('--vocab',
'-v',
type=str,
default='conversation_corpus/vocab.txt')
parser.add_argument('--seq_in',
'-i',
type=str,
default='conversation_corpus/input_sequence.txt')
parser.add_argument('--seq_out',
'-o',
type=str,
default='conversation_corpus/output_sequence.txt')
parser.add_argument('--epoch', '-e', type=int, default=100)
parser.add_argument('--log_epoch', type=int, default=1)
parser.add_argument('--alpha', '-a', type=float, default=0.001)
parser.add_argument('--gpu', '-g', type=int, default=0)
parser.add_argument('--batch', '-b', type=int, default=64)
parser.add_argument('--layer', '-l', type=int, default=3)
parser.add_argument('--unit', '-u', type=int, default=256)
parser.add_argument('--lr_shift', '-s', action='store_true', default=False)
parser.add_argument('--resume', '-r', default='')
args = parser.parse_args()
# save didrectory
outdir = path.join(
ROOT_PATH,
'seq2seq_results/seq2seq_conversation_epoch_{}_layer_{}_unit_{}_vocab_{}'
.format(args.epoch, args.layer, args.unit,
args.vocab.strip().split('/')[-1].split('.')[0]))
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 param
print('# GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batch))
print('# Epoch: {}'.format(args.epoch))
print('# Adam alpha: {}'.format(args.alpha))
print('# embedID unit :{}'.format(args.unit))
print('# LSTM layer :{}'.format(args.layer))
print('# out directory :{}'.format(outdir))
print('# lr shift: {}'.format(args.lr_shift))
print('')
# load dataset
vocab_ids = load_vocab(args.vocab)
train_data = load_data(vocab_ids, args.seq_in, args.seq_out)
# prepare model
model = Seq2seq(n_layers=args.layer,
n_vocab=len(vocab_ids),
n_units=args.unit)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
# optimizer
optimizer = chainer.optimizers.Adam(alpha=args.alpha)
optimizer.setup(model)
# iter
train_iter = chainer.iterators.SerialIterator(train_data, args.batch)
# trainer
updater = training.StandardUpdater(train_iter,
optimizer,
converter=convert,
device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=outdir)
# extention
# lr shift
if args.lr_shift:
trainer.extend(extensions.ExponentialShift("alpha", 0.1),
trigger=(200, 'epoch'))
# log
trainer.extend(extensions.LogReport(trigger=(args.log_epoch, 'epoch')))
trainer.extend(extensions.observe_lr(), trigger=(args.log_epoch, 'epoch'))
# print info
trainer.extend(extensions.PrintReport(
['epoch', 'iteration', 'main/loss', 'main/perp', 'lr',
'elapsed_time']),
trigger=(args.log_epoch, 'epoch'))
# print progbar
trainer.extend(extensions.ProgressBar())
# plot loss graph
trainer.extend(
extensions.PlotReport(['main/loss'], 'epoch', file_name='loss.png'))
# save snapshot and model
trainer.extend(extensions.snapshot(), trigger=(10, 'epoch'))
trainer.extend(extensions.snapshot_object(
model, 'model_snapshot_{.updater.epoch}'),
trigger=(10, 'epoch'))
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# [ChainerUI] enable to send commands from ChainerUI
trainer.extend(CommandsExtension())
# [ChainerUI] save 'args' to show experimental conditions
save_args(args, outdir)
# start learn
print('start training')
trainer.run()
# save final model
chainer.serializers.save_npz(
path.join(outdir, "seq2seq_conversation_model.npz"), model)
def main(args=None):
set_random_seed(63)
chainer.global_config.autotune = True
chainer.cuda.set_max_workspace_size(512 * 1024 * 1024)
parser = argparse.ArgumentParser()
parser.add_argument('--batchsize',
'-b',
type=int,
default=64,
help='Number of images in each mini-batch')
parser.add_argument('--learnrate',
'-l',
type=float,
default=0.01,
help='Learning rate for SGD')
parser.add_argument('--epoch',
'-e',
type=int,
default=80,
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('--out',
'-o',
default='result',
help='Directory to output the result')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the training from snapshot')
parser.add_argument('--loss-function',
choices=['focal', 'sigmoid'],
default='focal')
parser.add_argument('--optimizer',
choices=['sgd', 'adam', 'adabound'],
default='adam')
parser.add_argument('--size', type=int, default=224)
parser.add_argument('--limit', type=int, default=None)
parser.add_argument('--data-dir', type=str, default='data')
parser.add_argument('--lr-search', action='store_true')
parser.add_argument('--pretrained', type=str, default='')
parser.add_argument('--backbone',
choices=['resnet', 'seresnet', 'debug_model'],
default='resnet')
parser.add_argument('--log-interval', type=int, default=100)
parser.add_argument('--find-threshold', action='store_true')
parser.add_argument('--finetune', action='store_true')
parser.add_argument('--mixup', action='store_true')
args = parser.parse_args() if args is None else parser.parse_args(args)
print(args)
if args.mixup and args.loss_function != 'focal':
raise ValueError('mixupを使うときはfocal lossしか使えません（いまんところ）')
train, test, cooccurrence = get_dataset(args.data_dir, args.size,
args.limit, args.mixup)
base_model = backbone_catalog[args.backbone](args.dropout)
if args.pretrained:
print('loading pretrained model: {}'.format(args.pretrained))
chainer.serializers.load_npz(args.pretrained, base_model, strict=False)
model = TrainChain(base_model,
1,
loss_fn=args.loss_function,
cooccurrence=cooccurrence,
co_coef=0)
if args.gpu >= 0:
chainer.backends.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
if args.optimizer in ['adam', 'adabound']:
optimizer = Adam(alpha=args.learnrate,
adabound=args.optimizer == 'adabound',
weight_decay_rate=1e-5,
gamma=5e-7)
elif args.optimizer == 'sgd':
optimizer = chainer.optimizers.MomentumSGD(lr=args.learnrate)
optimizer.setup(model)
if not args.finetune:
print('最初のエポックは特徴抽出層をfreezeします')
model.freeze_extractor()
train_iter = chainer.iterators.MultiprocessIterator(train,
args.batchsize,
n_processes=8,
n_prefetch=2)
test_iter = chainer.iterators.MultithreadIterator(test,
args.batchsize,
n_threads=8,
repeat=False,
shuffle=False)
if args.find_threshold:
# train_iter, optimizerなど無駄なsetupもあるが。。
print('thresholdを探索して終了します')
chainer.serializers.load_npz(join(args.out, 'bestmodel_loss'),
base_model)
print('lossがもっとも小さかったモデルに対しての結果:')
find_threshold(base_model, test_iter, args.gpu, args.out)
chainer.serializers.load_npz(join(args.out, 'bestmodel_f2'),
base_model)
print('f2がもっとも大きかったモデルに対しての結果:')
find_threshold(base_model, test_iter, args.gpu, args.out)
return
# Set up a trainer
updater = training.updaters.StandardUpdater(
train_iter,
optimizer,
device=args.gpu,
converter=lambda batch, device: chainer.dataset.concat_examples(
batch, device=device))
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
# Evaluate the model with the test dataset for each epoch
trainer.extend(FScoreEvaluator(test_iter, model, device=args.gpu))
if args.optimizer == 'sgd':
# Adamにweight decayはあんまりよくないらしい
optimizer.add_hook(chainer.optimizer_hooks.WeightDecay(5e-4))
trainer.extend(extensions.ExponentialShift('lr', 0.1),
trigger=(3, 'epoch'))
if args.lr_search:
print('最適な学習率を探します')
trainer.extend(LRFinder(1e-7, 1, 5, optimizer),
trigger=(1, 'iteration'))
elif args.optimizer in ['adam', 'adabound']:
if args.lr_search:
print('最適な学習率を探します')
trainer.extend(LRFinder(1e-7, 1, 5, optimizer, lr_key='alpha'),
trigger=(1, 'iteration'))
trainer.extend(extensions.ExponentialShift('alpha', 0.2),
trigger=triggers.EarlyStoppingTrigger(
monitor='validation/main/loss'))
# Take a snapshot of Trainer at each epoch
trainer.extend(
extensions.snapshot(filename='snaphot_epoch_{.updater.epoch}'),
trigger=(10, 'epoch'))
# Take a snapshot of Model which has best val loss.
# Because searching best threshold for each evaluation takes too much time.
trainer.extend(extensions.snapshot_object(model.model, 'bestmodel_loss'),
trigger=triggers.MinValueTrigger('validation/main/loss'))
trainer.extend(extensions.snapshot_object(model.model, 'bestmodel_f2'),
trigger=triggers.MaxValueTrigger('validation/main/f2'))
trainer.extend(extensions.snapshot_object(model.model,
'model_{.updater.epoch}'),
trigger=(5, 'epoch'))
# Write a log of evaluation statistics for each epoch
trainer.extend(
extensions.LogReport(trigger=(args.log_interval, 'iteration')))
trainer.extend(
extensions.PrintReport([
'epoch', 'lr', 'elapsed_time', 'main/loss', 'main/co_loss',
'validation/main/loss', 'validation/main/co_loss',
'validation/main/precision', 'validation/main/recall',
'validation/main/f2', 'validation/main/threshold'
]))
trainer.extend(extensions.ProgressBar(update_interval=args.log_interval))
trainer.extend(extensions.observe_lr(),
trigger=(args.log_interval, 'iteration'))
trainer.extend(CommandsExtension())
save_args(args, args.out)
trainer.extend(lambda trainer: model.unfreeze_extractor(),
trigger=(1, 'epoch'))
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# save args with pickle for prediction time
pickle.dump(args, open(str(Path(args.out).joinpath('args.pkl')), 'wb'))
# Run the training
trainer.run()
# find optimal threshold
chainer.serializers.load_npz(join(args.out, 'bestmodel_loss'), base_model)
print('lossがもっとも小さかったモデルに対しての結果:')
find_threshold(base_model, test_iter, args.gpu, args.out)
chainer.serializers.load_npz(join(args.out, 'bestmodel_f2'), base_model)
print('f2がもっとも大きかったモデルに対しての結果:')
find_threshold(base_model, test_iter, args.gpu, args.out)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--config_path', type=str, default='configs/base.yml')
parser.add_argument('--n_devices', type=int)
parser.add_argument('--test', action='store_true', default=False)
parser.add_argument('--communicator', type=str,
default='hierarchical', help='Type of communicator')
parser.add_argument('--results_dir', type=str, default='results_rocgan')
parser.add_argument('--inception_model_path', type=str,
default='/home/user/inception/inception.model')
parser.add_argument('--resume', type=str, default='')
parser.add_argument('--enc_snapshot', type=str, default=None, help='path to the encoder snapshot')
parser.add_argument('--dec_snapshot', type=str, default=None, help='path to the decoder snapshot')
parser.add_argument('--dis_snapshot', type=str, default=None, help='path to the discriminator snapshot')
parser.add_argument('--loaderjob', type=int,
help='Number of parallel data loading processes')
parser.add_argument('--multiprocessing', action='store_true', default=False)
parser.add_argument('--validation', type=int, default=1)
parser.add_argument('--valid_fn', type=str, default='files_valid_4k.txt',
help='filename of the validation file')
parser.add_argument('--label', type=str, default='synth')
parser.add_argument('--stats_fid', type=str, default='', help='path for FID stats')
args = parser.parse_args()
config = yaml_utils.Config(yaml.load(open(args.config_path)))
# # ensure that the paths of the config are correct.
config = ensure_config_paths(config)
comm = chainermn.create_communicator(args.communicator)
device = comm.intra_rank
chainer.cuda.get_device_from_id(device).use()
# # get the pc name, e.g. for chainerui.
pcname = gethostname()
imperialpc = 'doc.ic.ac.uk' in pcname or pcname in ['ladybug', 'odysseus']
print('Init on pc: {}.'.format(pcname))
if comm.rank == 0:
print('==========================================')
print('Using {} communicator'.format(args.communicator))
print('==========================================')
enc, dec, dis = load_models_cgan(config)
if chainer.cuda.available:
enc.to_gpu()
dec.to_gpu()
dis.to_gpu()
else:
print('No GPU found!!!\n')
mma1 = ModelMovingAverage(0.999, enc)
mma2 = ModelMovingAverage(0.999, dec)
models = {'enc': enc, 'dec': dec, 'dis': dis}
if args.enc_snapshot is not None:
print('Loading encoder: {}.'.format(args.enc_snapshot))
chainer.serializers.load_npz(args.enc_snapshot, enc)
if args.dec_snapshot is not None:
print('Loading decoder: {}.'.format(args.dec_snapshot))
chainer.serializers.load_npz(args.dec_snapshot, dec)
if args.dis_snapshot is not None:
print('Loading discriminator: {}.'.format(args.dis_snapshot))
chainer.serializers.load_npz(args.dis_snapshot, dis)
# # convenience function for optimizer:
func_opt = lambda net: make_optimizer(net, comm, chmn=args.multiprocessing,
alpha=config.adam['alpha'], beta1=config.adam['beta1'],
beta2=config.adam['beta2'])
# Optimizer
opt_enc = func_opt(enc)
opt_dec = func_opt(dec)
opt_dis = func_opt(dis)
opts = {'opt_enc': opt_enc, 'opt_dec': opt_dec, 'opt_dis': opt_dis}
# Dataset
if comm.rank == 0:
dataset = yaml_utils.load_dataset(config)
printtime('Length of dataset: {}.'.format(len(dataset)))
if args.validation:
# # add the validation db if we do perform validation.
db_valid = yaml_utils.load_dataset(config, validation=True, valid_path=args.valid_fn)
else:
_ = yaml_utils.load_dataset(config) # Dummy, for adding path to the dataset module
dataset = None
if args.validation:
_ = yaml_utils.load_dataset(config, validation=True, valid_path=args.valid_fn)
db_valid = None
dataset = chainermn.scatter_dataset(dataset, comm)
if args.validation:
db_valid = chainermn.scatter_dataset(db_valid, comm)
# Iterator
multiprocessing.set_start_method('forkserver')
if args.multiprocessing:
# # In minoas this might fail with the forkserver.py error.
iterator = chainer.iterators.MultiprocessIterator(dataset, config.batchsize,
n_processes=args.loaderjob)
if args.validation:
iter_val = chainer.iterators.MultiprocessIterator(db_valid, config.batchsize,
n_processes=args.loaderjob,
shuffle=False, repeat=False)
else:
iterator = chainer.iterators.SerialIterator(dataset, config.batchsize)
if args.validation:
iter_val = chainer.iterators.SerialIterator(db_valid, config.batchsize,
shuffle=False, repeat=False)
kwargs = config.updater['args'] if 'args' in config.updater else {}
kwargs.update({
'models': models,
'iterator': iterator,
'optimizer': opts,
'device': device,
'mma1': mma1,
'mma2': mma2,
})
updater = yaml_utils.load_updater_class(config)
updater = updater(**kwargs)
if not args.test:
mainf = '{}_{}'.format(strftime('%Y_%m_%d__%H_%M_%S'), args.label)
out = os.path.join(args.results_dir, mainf, '')
else:
out = 'results/test'
if comm.rank == 0:
create_result_dir(out, args.config_path, config)
trainer = training.Trainer(updater, (config.iteration, 'iteration'), out=out)
# # abbreviations below: inc -> incpetion, gadv -> grad_adv, lgen -> loss gener,
# # {m, sd, b}[var] -> {mean, std, best position} [var],
report_keys = ['loss_dis', 'lgen_adv', 'dis_real', 'dis_fake', 'loss_l1',
'mssim', 'sdssim', 'mmae', 'loss_projl', 'FID']
if comm.rank == 0:
# Set up logging
for m in models.values():
trainer.extend(extensions.snapshot_object(
m, m.__class__.__name__ + '_{.updater.iteration}.npz'), trigger=(config.snapshot_interval, 'iteration'))
# trainer.extend(extensions.snapshot_object(
# mma.avg_model, mma.avg_model.__class__.__name__ + '_avgmodel_{.updater.iteration}.npz'),
# trigger=(config.snapshot_interval, 'iteration'))
trainer.extend(extensions.LogReport(trigger=(config.display_interval, 'iteration')))
trainer.extend(extensions.PrintReport(report_keys), trigger=(config.display_interval, 'iteration'))
if args.validation:
# # add the appropriate extension for validating the model.
models_mma = {'enc': mma1.avg_model, 'dec': mma2.avg_model, 'dis': dis}
trainer.extend(validation_trainer(models_mma, iter_val, n=len(db_valid), export_best=True,
pout=out, p_inc=args.inception_model_path, eval_fid=True,
sfile=args.stats_fid),
trigger=(config.evaluation_interval, 'iteration'),
priority=extension.PRIORITY_WRITER)
trainer.extend(extensions.ProgressBar(update_interval=config.display_interval))
if imperialpc:
# [ChainerUI] Observe learning rate
trainer.extend(extensions.observe_lr(optimizer_name='opt_dis'))
# [ChainerUI] enable to send commands from ChainerUI
trainer.extend(CommandsExtension())
# [ChainerUI] save 'args' to show experimental conditions
save_args(args, out)
# # convenience function for linearshift in optimizer:
func_opt_shift = lambda optim1: extensions.LinearShift('alpha', (config.adam['alpha'], 0.),
(config.iteration_decay_start,
config.iteration), optim1)
# # define the actual extensions (for optimizer shift).
trainer.extend(func_opt_shift(opt_enc))
trainer.extend(func_opt_shift(opt_dec))
trainer.extend(func_opt_shift(opt_dis))
if args.resume:
print('Resume Trainer')
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
printtime('start training')
trainer.run()
plot_losses_log(out, savefig=True)
def main():
parser = argparse.ArgumentParser(description='Mask R-CNN')
parser.add_argument('--gpu', '-g', type=int, default=0)
parser.add_argument('--lr', '-l', type=float, default=1e-3)
parser.add_argument('--out',
'-o',
default='result',
help='Output directory')
parser.add_argument('--iteration', '-i', type=int, default=200000)
parser.add_argument('--weight', '-w', type=str, default='')
parser.add_argument('--label_file',
'-f',
type=str,
default='data/label_coco.txt')
parser.add_argument('--backbone', type=str, default='fpn')
parser.add_argument('--head_arch', '-a', type=str, default='fpn')
parser.add_argument('--multi_gpu', '-m', type=int, default=0)
parser.add_argument('--batch_size', '-b', type=int, default=1)
args = parser.parse_args()
print('lr:{}'.format(args.lr))
print('output:{}'.format(args.out))
print('weight:{}'.format(args.weight))
print('label file:{}'.format(args.label_file))
print('iteration::{}'.format(args.iteration))
print('backbone architecture:{}'.format(args.backbone))
print('head architecture:{}'.format(args.head_arch))
if args.multi_gpu:
print(
'try to use chainer.training.updaters.MultiprocessParallelUpdater')
if not chainer.training.updaters.MultiprocessParallelUpdater.available(
):
print('MultiprocessParallelUpdater is not available')
args.multi_gpu = 0
with open(args.label_file, "r") as f:
labels = f.read().strip().split("\n")
faster_rcnn = MaskRCNNResnet50(n_fg_class=len(labels),
backbone=args.backbone,
head_arch=args.head_arch)
faster_rcnn.use_preset('evaluate')
model = FPNMaskRCNNTrainChain(faster_rcnn, mask_loss_fun=calc_mask_loss)
if exists(args.weight):
chainer.serializers.load_npz(args.weight,
model.faster_rcnn,
strict=False)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
optimizer = chainer.optimizers.MomentumSGD(lr=args.lr, momentum=0.9)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(rate=0.0005))
pkl_file = 'train_data.pkl'
if isfile(pkl_file):
print('pklから読み込みます')
dataload_start = time.time()
with open(pkl_file, 'rb') as f:
coco_train_data = pickle.load(f)
dataload_end = time.time()
print('pklからの読み込み {}'.format(dataload_end - dataload_start))
else:
dataload_start = time.time()
coco_train_data = COCOMaskLoader(category_filter=labels)
dataload_end = time.time()
print('普通の読み込み {}'.format(dataload_end - dataload_start))
print('次回のために保存します')
with open(pkl_file, 'wb') as f:
pickle.dump(coco_train_data, f)
train_data = TransformDataset(coco_train_data, Transform(faster_rcnn))
if args.multi_gpu:
train_iters = [
chainer.iterators.SerialIterator(train_data,
1,
repeat=True,
shuffle=True) for i in range(8)
]
updater = chainer.training.updater.MultiprocessParallelUpdater(
train_iters, optimizer, device=range(8))
else:
train_iter = chainer.iterators.SerialIterator(
train_data, batch_size=args.batch_size, repeat=True, shuffle=False)
updater = chainer.training.updater.StandardUpdater(train_iter,
optimizer,
device=args.gpu)
trainer = chainer.training.Trainer(updater, (args.iteration, 'iteration'),
args.out)
trainer.extend(extensions.snapshot_object(
model.faster_rcnn, 'model_{.updater.iteration}.npz'),
trigger=(5000, 'iteration'))
trainer.extend(extensions.ExponentialShift('lr', 0.1),
trigger=(2, 'epoch'))
log_interval = 100, 'iteration'
trainer.extend(chainer.training.extensions.observe_lr(),
trigger=log_interval)
trainer.extend(extensions.LogReport(trigger=log_interval))
trainer.extend(extensions.PrintReport([
'iteration',
'epoch',
'elapsed_time',
'lr',
'main/loss',
'main/mask_loss',
'main/roi_loc_loss',
'main/roi_cls_loss',
'main/rpn_loc_loss',
'main/rpn_cls_loss',
]),
trigger=(100, 'iteration'))
trainer.extend(extensions.ProgressBar(update_interval=200))
trainer.extend(extensions.dump_graph('main/loss'))
save_args(args, args.out)
trainer.extend(CommandsExtension(), trigger=(100, 'iteration'))
trainer.run()
def main():
parser = argparse.ArgumentParser(description='Chainer example: MNIST')
parser.add_argument('--batchsize',
'-b',
type=int,
default=100,
help='Number of images in each mini-batch')
parser.add_argument('--epoch',
'-e',
type=int,
default=20,
help='Number of sweeps over the dataset to train')
parser.add_argument('--frequency',
'-f',
type=int,
default=-1,
help='Frequency of taking a snapshot')
parser.add_argument('--gpu',
'-g',
type=int,
default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--out',
'-o',
default='result',
help='Directory to output the result')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the training from snapshot')
parser.add_argument('--unit',
'-u',
type=int,
default=1000,
help='Number of units')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# unit: {}'.format(args.unit))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
# Set up a neural network to train
# Classifier reports softmax cross entropy loss and accuracy at every
# iteration, which will be used by the PrintReport extension below.
model = L.Classifier(MLP(args.unit, 10))
if args.gpu >= 0:
# Make a specified GPU current
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu() # Copy the model to the GPU
# Setup an optimizer
# [ChainerUI] change optimizer from Adam to observe leanring rate
optimizer = chainer.optimizers.MomentumSGD()
optimizer.setup(model)
# Load the MNIST dataset
train, test = chainer.datasets.get_mnist()
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test,
args.batchsize,
repeat=False,
shuffle=False)
# Set up a trainer
updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
# Evaluate the model with the test dataset for each epoch
trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu))
# Dump a computational graph from 'loss' variable at the first iteration
# The "main" refers to the target link of the "main" optimizer.
trainer.extend(extensions.dump_graph('main/loss'))
# Take a snapshot for each specified epoch
frequency = args.epoch if args.frequency == -1 else max(1, args.frequency)
trainer.extend(extensions.snapshot(), trigger=(frequency, 'epoch'))
# Write a log of evaluation statistics for each epoch
# [ChainerUI] read 'log' file for plotting values
trainer.extend(extensions.LogReport())
# Save two plot images to the result dir
if extensions.PlotReport.available():
trainer.extend(
extensions.PlotReport(['main/loss', 'validation/main/loss'],
'epoch',
file_name='loss.png'))
trainer.extend(
extensions.PlotReport(
['main/accuracy', 'validation/main/accuracy'],
'epoch',
file_name='accuracy.png'))
# Print selected entries of the log to stdout
# Here "main" refers to the target link of the "main" optimizer again, and
# "validation" refers to the default name of the Evaluator extension.
# Entries other than 'epoch' are reported by the Classifier link, called by
# either the updater or the evaluator.
trainer.extend(
extensions.PrintReport([
'epoch', 'main/loss', 'validation/main/loss', 'main/accuracy',
'validation/main/accuracy', 'lr', 'elapsed_time'
]))
# Print a progress bar to stdout
trainer.extend(extensions.ProgressBar())
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# [ChainerUI] Observe learning rate
trainer.extend(extensions.observe_lr())
# [ChainerUI] enable to send commands from ChainerUI
trainer.extend(CommandsExtension())
# [ChainerUI] save 'args' to show experimental conditions
save_args(args, args.out)
# Run the training
trainer.run()
def main():
args = arguments()
print(args)
if args.imgtype == "dcm":
from dataset_dicom import Dataset as Dataset
else:
from dataset_jpg import DatasetOutMem as Dataset
# CUDA
if not chainer.cuda.available:
print("CUDA required")
exit()
if len(args.gpu) == 1 and args.gpu[0] >= 0:
chainer.cuda.get_device_from_id(args.gpu[0]).use()
# Enable autotuner of cuDNN
chainer.config.autotune = True
chainer.config.dtype = dtypes[args.dtype]
chainer.print_runtime_info()
# Turn off type check
# chainer.config.type_check = False
# print('Chainer version: ', chainer.__version__)
# print('GPU availability:', chainer.cuda.available)
# print('cuDNN availablility:', chainer.cuda.cudnn_enabled)
## dataset iterator
print("Setting up data iterators...")
train_A_dataset = Dataset(path=os.path.join(args.root, 'trainA'),
args=args,
base=args.HU_baseA,
rang=args.HU_rangeA,
random=args.random_translate)
train_B_dataset = Dataset(path=os.path.join(args.root, 'trainB'),
args=args,
base=args.HU_baseB,
rang=args.HU_rangeB,
random=args.random_translate)
test_A_dataset = Dataset(path=os.path.join(args.root, 'testA'),
args=args,
base=args.HU_baseA,
rang=args.HU_rangeA,
random=0)
test_B_dataset = Dataset(path=os.path.join(args.root, 'testB'),
args=args,
base=args.HU_baseB,
rang=args.HU_rangeB,
random=0)
args.ch = train_A_dataset.ch
args.out_ch = train_B_dataset.ch
print("channels in A {}, channels in B {}".format(args.ch, args.out_ch))
# test_A_iter = chainer.iterators.SerialIterator(test_A_dataset, args.nvis_A, shuffle=False)
# test_B_iter = chainer.iterators.SerialIterator(test_B_dataset, args.nvis_B, shuffle=False)
test_A_iter = chainer.iterators.MultithreadIterator(test_A_dataset,
args.nvis_A,
shuffle=False,
n_threads=3)
test_B_iter = chainer.iterators.MultithreadIterator(test_B_dataset,
args.nvis_B,
shuffle=False,
n_threads=3)
train_A_iter = chainer.iterators.MultithreadIterator(train_A_dataset,
args.batch_size,
n_threads=3)
train_B_iter = chainer.iterators.MultithreadIterator(train_B_dataset,
args.batch_size,
n_threads=3)
# setup models
enc_x = Encoder(args)
enc_y = enc_x if args.single_encoder else Encoder(args)
dec_x = Decoder(args)
dec_y = Decoder(args)
dis_x = Discriminator(args)
dis_y = Discriminator(args)
dis_z = Discriminator(
args) if args.lambda_dis_z > 0 else chainer.links.Linear(1, 1)
models = {
'enc_x': enc_x,
'dec_x': dec_x,
'enc_y': enc_y,
'dec_y': dec_y,
'dis_x': dis_x,
'dis_y': dis_y,
'dis_z': dis_z
}
## load learnt models
if args.load_models:
for e in models:
m = args.load_models.replace('enc_x', e)
try:
serializers.load_npz(m, models[e])
print('model loaded: {}'.format(m))
except:
print("couldn't load {}".format(m))
pass
# select GPU
if len(args.gpu) == 1:
for e in models:
models[e].to_gpu()
print('using gpu {}, cuDNN {}'.format(args.gpu,
chainer.cuda.cudnn_enabled))
else:
print("mandatory GPU use: currently only a single GPU can be used")
exit()
# Setup optimisers
def make_optimizer(model, lr, opttype='Adam'):
# eps = 1e-5 if args.dtype==np.float16 else 1e-8
optimizer = optim[opttype](lr)
#from profiled_optimizer import create_marked_profile_optimizer
# optimizer = create_marked_profile_optimizer(optim[opttype](lr), sync=True, sync_level=2)
optimizer.setup(model)
if args.weight_decay > 0:
if opttype in ['Adam', 'AdaBound', 'Eve']:
optimizer.weight_decay_rate = args.weight_decay
else:
if args.weight_decay_norm == 'l2':
optimizer.add_hook(
chainer.optimizer.WeightDecay(args.weight_decay))
else:
optimizer.add_hook(
chainer.optimizer_hooks.Lasso(args.weight_decay))
return optimizer
opt_enc_x = make_optimizer(enc_x, args.learning_rate_g, args.optimizer)
opt_dec_x = make_optimizer(dec_x, args.learning_rate_g, args.optimizer)
opt_enc_y = make_optimizer(enc_y, args.learning_rate_g, args.optimizer)
opt_dec_y = make_optimizer(dec_y, args.learning_rate_g, args.optimizer)
opt_x = make_optimizer(dis_x, args.learning_rate_d, args.optimizer)
opt_y = make_optimizer(dis_y, args.learning_rate_d, args.optimizer)
opt_z = make_optimizer(dis_z, args.learning_rate_d, args.optimizer)
optimizers = {
'opt_enc_x': opt_enc_x,
'opt_dec_x': opt_dec_x,
'opt_enc_y': opt_enc_y,
'opt_dec_y': opt_dec_y,
'opt_x': opt_x,
'opt_y': opt_y,
'opt_z': opt_z
}
if args.load_optimizer:
for e in optimizers:
try:
m = args.load_models.replace('enc_x', e)
serializers.load_npz(m, optimizers[e])
print('optimiser loaded: {}'.format(m))
except:
print("couldn't load {}".format(m))
pass
# Set up an updater: TODO: multi gpu updater
print("Preparing updater...")
updater = Updater(models=(enc_x, dec_x, enc_y, dec_y, dis_x, dis_y, dis_z),
iterator={
'main': train_A_iter,
'train_B': train_B_iter,
},
optimizer=optimizers,
converter=convert.ConcatWithAsyncTransfer(),
device=args.gpu[0],
params={'args': args})
if args.snapinterval < 0:
args.snapinterval = args.lrdecay_start + args.lrdecay_period
log_interval = (200, 'iteration')
model_save_interval = (args.snapinterval, 'epoch')
plot_interval = (500, 'iteration')
# Set up a trainer
print("Preparing trainer...")
if args.iteration:
stop_trigger = (args.iteration, 'iteration')
else:
stop_trigger = (args.lrdecay_start + args.lrdecay_period, 'epoch')
trainer = training.Trainer(updater, stop_trigger, out=args.out)
for e in models:
trainer.extend(extensions.snapshot_object(models[e],
e + '{.updater.epoch}.npz'),
trigger=model_save_interval)
# trainer.extend(extensions.ParameterStatistics(models[e])) ## very slow
for e in optimizers:
trainer.extend(extensions.snapshot_object(optimizers[e],
e + '{.updater.epoch}.npz'),
trigger=model_save_interval)
log_keys = ['epoch', 'iteration', 'lr']
log_keys_cycle = [
'opt_enc_x/loss_cycle', 'opt_enc_y/loss_cycle', 'opt_dec_x/loss_cycle',
'opt_dec_y/loss_cycle', 'myval/cycle_x_l1', 'myval/cycle_y_l1'
]
log_keys_adv = [
'opt_enc_y/loss_adv', 'opt_dec_y/loss_adv', 'opt_enc_x/loss_adv',
'opt_dec_x/loss_adv'
]
log_keys_d = []
if args.lambda_reg > 0:
log_keys.extend(['opt_enc_x/loss_reg', 'opt_enc_y/loss_reg'])
if args.lambda_tv > 0:
log_keys.extend(['opt_dec_y/loss_tv'])
if args.lambda_air > 0:
log_keys.extend(['opt_dec_x/loss_air', 'opt_dec_y/loss_air'])
if args.lambda_grad > 0:
log_keys.extend(['opt_dec_x/loss_grad', 'opt_dec_y/loss_grad'])
if args.lambda_identity_x > 0: # perceptual
log_keys.extend(['opt_enc_x/loss_id', 'opt_enc_y/loss_id'])
if args.lambda_domain > 0:
log_keys_cycle.extend(['opt_dec_x/loss_dom', 'opt_dec_y/loss_dom'])
if args.dis_reg_weighting > 0:
log_keys_d.extend(
['opt_x/loss_reg', 'opt_y/loss_reg', 'opt_z/loss_reg'])
if args.dis_wgan:
log_keys_d.extend([
'opt_x/loss_dis', 'opt_x/loss_gp', 'opt_y/loss_dis',
'opt_y/loss_gp'
])
if args.lambda_dis_z > 0:
log_keys_d.extend(['opt_z/loss_dis', 'opt_z/loss_gp'])
else:
log_keys_d.extend([
'opt_x/loss_real', 'opt_x/loss_fake', 'opt_y/loss_real',
'opt_y/loss_fake'
])
if args.lambda_dis_z > 0:
log_keys_d.extend(['opt_z/loss_x', 'opt_z/loss_y'])
log_keys_all = log_keys + log_keys_d + log_keys_adv + log_keys_cycle
trainer.extend(
extensions.LogReport(keys=log_keys_all, trigger=log_interval))
trainer.extend(extensions.PrintReport(log_keys_all), trigger=log_interval)
trainer.extend(extensions.ProgressBar(update_interval=20))
trainer.extend(extensions.observe_lr(optimizer_name='opt_enc_x'),
trigger=log_interval)
# learning rate scheduling
decay_start_iter = len(train_A_dataset) * args.lrdecay_start
decay_end_iter = len(train_A_dataset) * (args.lrdecay_start +
args.lrdecay_period)
for e in [opt_enc_x, opt_enc_y, opt_dec_x, opt_dec_y]:
trainer.extend(
extensions.LinearShift('alpha', (args.learning_rate_g, 0),
(decay_start_iter, decay_end_iter),
optimizer=e))
for e in [opt_x, opt_y, opt_z]:
trainer.extend(
extensions.LinearShift('alpha', (args.learning_rate_d, 0),
(decay_start_iter, decay_end_iter),
optimizer=e))
## dump graph
if args.lambda_Az > 0:
trainer.extend(
extensions.dump_graph('opt_enc_x/loss_cycle', out_name='gen.dot'))
if args.lambda_dis_x > 0:
if args.dis_wgan:
trainer.extend(
extensions.dump_graph('opt_x/loss_dis', out_name='dis.dot'))
else:
trainer.extend(
extensions.dump_graph('opt_x/loss_fake', out_name='dis.dot'))
# ChainerUI
trainer.extend(CommandsExtension())
if extensions.PlotReport.available():
trainer.extend(
extensions.PlotReport(log_keys[3:],
'iteration',
trigger=plot_interval,
file_name='loss.png',
postprocess=plot_log))
trainer.extend(
extensions.PlotReport(log_keys_d,
'iteration',
trigger=plot_interval,
file_name='loss_d.png'))
trainer.extend(
extensions.PlotReport(log_keys_adv,
'iteration',
trigger=plot_interval,
file_name='loss_adv.png'))
trainer.extend(
extensions.PlotReport(log_keys_cycle,
'iteration',
trigger=plot_interval,
file_name='loss_cyc.png',
postprocess=plot_log))
## visualisation
vis_folder = os.path.join(args.out, "vis")
os.makedirs(vis_folder, exist_ok=True)
if not args.vis_freq:
args.vis_freq = len(train_A_dataset) // 2
s = [k for k in range(args.num_slices)
] if args.num_slices > 0 and args.imgtype == "dcm" else None
trainer.extend(VisEvaluator({
"testA": test_A_iter,
"testB": test_B_iter
}, {
"enc_x": enc_x,
"enc_y": enc_y,
"dec_x": dec_x,
"dec_y": dec_y
},
params={
'vis_out': vis_folder,
'slice': s,
'args': args
},
device=args.gpu[0]),
trigger=(args.vis_freq, 'iteration'))
## output filenames of training dataset
with open(os.path.join(args.out, 'trainA.txt'), 'w') as output:
for f in train_A_dataset.names:
output.writelines("\n".join(f))
output.writelines("\n")
with open(os.path.join(args.out, 'trainB.txt'), 'w') as output:
for f in train_B_dataset.names:
output.writelines("\n".join(f))
output.writelines("\n")
# archive the scripts
rundir = os.path.dirname(os.path.realpath(__file__))
import zipfile
with zipfile.ZipFile(os.path.join(args.out, 'script.zip'),
'w',
compression=zipfile.ZIP_DEFLATED) as new_zip:
for f in [
'train.py', 'net.py', 'updater.py', 'consts.py', 'losses.py',
'arguments.py', 'convert.py'
]:
new_zip.write(os.path.join(rundir, f), arcname=f)
# Run the training
print("\nresults are saved under: ", args.out)
save_args(args, args.out)
with open(os.path.join(args.out, "args.txt"), 'w') as fh:
fh.write(" ".join(sys.argv))
trainer.run()
def main():
args = arguments()
out = os.path.join(args.out, dt.now().strftime('%m%d_%H%M_AE'))
print(args)
print(out)
save_args(args, out)
args.dtype = dtypes[args.dtype]
args.dis_activation = activation[args.dis_activation]
args.gen_activation = activation[args.gen_activation]
args.gen_out_activation = activation[args.gen_out_activation]
args.gen_nblock = args.gen_nblock // 2 # to match ordinary cycleGAN
if args.imgtype=="dcm":
from dataset_dicom import DatasetOutMem as Dataset
else:
from dataset_jpg import DatasetOutMem as Dataset
if not chainer.cuda.available:
print("CUDA required")
if len(args.gpu)==1 and args.gpu[0] >= 0:
chainer.cuda.get_device_from_id(args.gpu[0]).use()
# Enable autotuner of cuDNN
chainer.config.autotune = True
chainer.config.dtype = args.dtype
chainer.print_runtime_info()
# Turn off type check
# chainer.config.type_check = False
# print('Chainer version: ', chainer.__version__)
# print('GPU availability:', chainer.cuda.available)
# print('cuDNN availablility:', chainer.cuda.cudnn_enabled)
## dataset iterator
print("Setting up data iterators...")
train_A_dataset = Dataset(
path=os.path.join(args.root, 'trainA'), baseA=args.HU_base, rangeA=args.HU_range, slice_range=args.slice_range, crop=(args.crop_height,args.crop_width),random=args.random_translate, forceSpacing=0, imgtype=args.imgtype, dtype=args.dtype)
train_B_dataset = Dataset(
path=os.path.join(args.root, 'trainB'), baseA=args.HU_base, rangeA=args.HU_range, slice_range=args.slice_range, crop=(args.crop_height,args.crop_width), random=args.random_translate, forceSpacing=args.forceSpacing, imgtype=args.imgtype, dtype=args.dtype)
test_A_dataset = Dataset(
path=os.path.join(args.root, 'testA'), baseA=args.HU_base, rangeA=args.HU_range, slice_range=args.slice_range, crop=(args.crop_height,args.crop_width), random=0, forceSpacing=0, imgtype=args.imgtype, dtype=args.dtype)
test_B_dataset = Dataset(
path=os.path.join(args.root, 'testB'), baseA=args.HU_base, rangeA=args.HU_range, slice_range=args.slice_range, crop=(args.crop_height,args.crop_width), random=0, forceSpacing=args.forceSpacing, imgtype=args.imgtype, dtype=args.dtype)
args.ch = train_A_dataset.ch
test_A_iter = chainer.iterators.SerialIterator(test_A_dataset, args.nvis_A, shuffle=False)
test_B_iter = chainer.iterators.SerialIterator(test_B_dataset, args.nvis_B, shuffle=False)
if args.batch_size > 1:
train_A_iter = chainer.iterators.MultiprocessIterator(
train_A_dataset, args.batch_size, n_processes=3, shuffle=not args.conditional_discriminator)
train_B_iter = chainer.iterators.MultiprocessIterator(
train_B_dataset, args.batch_size, n_processes=3, shuffle=not args.conditional_discriminator)
else:
train_A_iter = chainer.iterators.SerialIterator(
train_A_dataset, args.batch_size, shuffle=not args.conditional_discriminator)
train_B_iter = chainer.iterators.SerialIterator(
train_B_dataset, args.batch_size, shuffle=not args.conditional_discriminator)
# setup models
enc_x = net.Encoder(args)
enc_y = net.Encoder(args)
dec_x = net.Decoder(args)
dec_y = net.Decoder(args)
dis_x = net.Discriminator(args)
dis_y = net.Discriminator(args)
dis_z = net.Discriminator(args)
models = {'enc_x': enc_x, 'enc_y': enc_y, 'dec_x': dec_x, 'dec_y': dec_y, 'dis_x': dis_x, 'dis_y': dis_y, 'dis_z': dis_z}
optimiser_files = []
## load learnt models
if args.load_models:
for e in models:
m = args.load_models.replace('enc_x',e)
try:
serializers.load_npz(m, models[e])
print('model loaded: {}'.format(m))
except:
print("couldn't load {}".format(m))
pass
optimiser_files.append(m.replace(e,'opt_'+e).replace('dis_',''))
# select GPU
if len(args.gpu) == 1:
for e in models:
models[e].to_gpu()
print('use gpu {}, cuDNN {}'.format(args.gpu, chainer.cuda.cudnn_enabled))
else:
print("mandatory GPU use: currently only a single GPU can be used")
exit()
# Setup optimisers
def make_optimizer(model, alpha=0.0002, beta1=0.5):
eps = 1e-5 if args.dtype==np.float16 else 1e-8
optimizer = chainer.optimizers.Adam(alpha=alpha, beta1=beta1, eps=eps)
optimizer.setup(model)
if args.weight_decay>0:
if args.weight_decay_norm =='l2':
optimizer.add_hook(chainer.optimizer.WeightDecay(args.weight_decay))
else:
optimizer.add_hook(chainer.optimizer_hooks.Lasso(args.weight_decay))
return optimizer
opt_enc_x = make_optimizer(enc_x, alpha=args.learning_rate_g)
opt_dec_x = make_optimizer(dec_x, alpha=args.learning_rate_g)
opt_enc_y = make_optimizer(enc_y, alpha=args.learning_rate_g)
opt_dec_y = make_optimizer(dec_y, alpha=args.learning_rate_g)
opt_x = make_optimizer(dis_x, alpha=args.learning_rate_d)
opt_y = make_optimizer(dis_y, alpha=args.learning_rate_d)
opt_z = make_optimizer(dis_z, alpha=args.learning_rate_d)
optimizers = {'opt_enc_x': opt_enc_x,'opt_dec_x': opt_dec_x,'opt_enc_y': opt_enc_y,'opt_dec_y': opt_dec_y,'opt_x': opt_x,'opt_y': opt_y,'opt_z': opt_z}
if args.load_optimizer:
for (m,e) in zip(optimiser_files,optimizers):
if m:
try:
serializers.load_npz(m, optimizers[e])
print('optimiser loaded: {}'.format(m))
except:
print("couldn't load {}".format(m))
pass
# Set up an updater: TODO: multi gpu updater
print("Preparing updater...")
updater = Updater(
models=(enc_x,dec_x,enc_y,dec_y, dis_x, dis_y, dis_z),
iterator={
'main': train_A_iter,
'train_B': train_B_iter,
},
optimizer=optimizers,
converter=convert.ConcatWithAsyncTransfer(),
device=args.gpu[0],
params={
'args': args
})
if args.snapinterval<0:
args.snapinterval = args.lrdecay_start+args.lrdecay_period
log_interval = (200, 'iteration')
model_save_interval = (args.snapinterval, 'epoch')
vis_interval = (args.vis_freq, 'iteration')
plot_interval = (500, 'iteration')
# Set up a trainer
print("Preparing trainer...")
trainer = training.Trainer(updater, (args.lrdecay_start + args.lrdecay_period, 'epoch'), out=out)
for e in models:
trainer.extend(extensions.snapshot_object(
models[e], e+'{.updater.epoch}.npz'), trigger=model_save_interval)
for e in optimizers:
trainer.extend(extensions.snapshot_object(
optimizers[e], e+'{.updater.epoch}.npz'), trigger=model_save_interval)
log_keys = ['epoch', 'iteration']
log_keys_cycle = ['opt_enc_x/loss_cycle', 'opt_enc_y/loss_cycle', 'opt_dec_x/loss_cycle', 'opt_dec_y/loss_cycle', 'myval/cycle_y_l1']
log_keys_d = ['opt_x/loss_real','opt_x/loss_fake','opt_y/loss_real','opt_y/loss_fake','opt_z/loss_x','opt_z/loss_y']
log_keys_adv = ['opt_enc_y/loss_adv','opt_dec_y/loss_adv','opt_enc_x/loss_adv','opt_dec_x/loss_adv']
log_keys.extend([ 'opt_dec_y/loss_id'])
log_keys.extend([ 'opt_enc_x/loss_reg','opt_enc_y/loss_reg', 'opt_dec_x/loss_air','opt_dec_y/loss_air', 'opt_dec_y/loss_tv'])
log_keys_d.extend(['opt_x/loss_gp','opt_y/loss_gp'])
log_keys_all = log_keys+log_keys_d+log_keys_adv+log_keys_cycle
trainer.extend(extensions.LogReport(keys=log_keys_all, trigger=log_interval))
trainer.extend(extensions.PrintReport(log_keys_all), trigger=log_interval)
trainer.extend(extensions.ProgressBar(update_interval=20))
trainer.extend(CommandsExtension())
## to dump graph, set -lix 1 --warmup 0
# trainer.extend(extensions.dump_graph('opt_g/loss_id', out_name='gen.dot'))
# trainer.extend(extensions.dump_graph('opt_x/loss', out_name='dis.dot'))
if extensions.PlotReport.available():
trainer.extend(extensions.PlotReport(log_keys[2:], 'iteration',trigger=plot_interval, file_name='loss.png'))
trainer.extend(extensions.PlotReport(log_keys_d, 'iteration', trigger=plot_interval, file_name='loss_d.png'))
trainer.extend(extensions.PlotReport(log_keys_adv, 'iteration', trigger=plot_interval, file_name='loss_adv.png'))
trainer.extend(extensions.PlotReport(log_keys_cycle, 'iteration', trigger=plot_interval, file_name='loss_cyc.png'))
## output filenames of training dataset
with open(os.path.join(out, 'trainA.txt'),'w') as output:
output.writelines("\n".join(train_A_dataset.ids))
with open(os.path.join(out, 'trainB.txt'),'w') as output:
output.writelines("\n".join(train_B_dataset.ids))
# archive the scripts
rundir = os.path.dirname(os.path.realpath(__file__))
import zipfile
with zipfile.ZipFile(os.path.join(out,'script.zip'), 'w', compression=zipfile.ZIP_DEFLATED) as new_zip:
for f in ['trainAE.py','net.py','updaterAE.py','consts.py','losses.py','arguments.py','convert.py']:
new_zip.write(os.path.join(rundir,f),arcname=f)
## visualisation
vis_folder = os.path.join(out, "vis")
if not os.path.exists(vis_folder):
os.makedirs(vis_folder)
# trainer.extend(visualize( (enc_x, enc_y, dec_y), vis_folder, test_A_iter, test_B_iter),trigger=(1, 'epoch'))
trainer.extend(VisEvaluator({"main":test_A_iter, "testB":test_B_iter}, {"enc_x":enc_x, "enc_y":enc_y,"dec_x":dec_x,"dec_y":dec_y},
params={'vis_out': vis_folder, 'single_encoder': args.single_encoder}, device=args.gpu[0]),trigger=vis_interval)
# Run the training
trainer.run()
def main():
parser = argparse.ArgumentParser(
description='chainer implementation of pix2pix', )
parser.add_argument(
'--batchsize',
'-b',
type=int,
default=1,
help='Number of images in each mini-batch',
)
parser.add_argument(
'--epoch',
'-e',
type=int,
default=200,
help='Number of sweeps over the dataset to train',
)
parser.add_argument(
'--base_ch',
type=int,
default=64,
help='base channel size of hidden layer',
)
parser.add_argument(
'--gpu',
'-g',
type=int,
default=-1,
help='GPU ID (negative value indicates CPU)',
)
parser.add_argument(
'--dataset',
'-i',
default='./image/fsm',
help='Directory of image files.',
)
parser.add_argument(
'--out',
'-o',
default='result',
help='Directory to output the result',
)
parser.add_argument(
'--resume',
'-r',
default='',
help='Resume the training from snapshot',
)
parser.add_argument(
'--snapshot_interval',
type=int,
default=1000,
help='Interval of snapshot',
)
parser.add_argument(
'--display_interval',
type=int,
default=10,
help='Interval of displaying log to console',
)
parser.add_argument(
'--preview_interval',
type=int,
default=100,
help='Interval of previewing generated image',
)
args = parser.parse_args()
save_args(args, args.out)
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
upscaler = Pix2Pix(in_ch=4, out_ch=4, base_ch=args.base_ch)
downscaler = Pix2Pix(in_ch=4, out_ch=4, base_ch=args.base_ch)
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use() # Make a specified GPU current
upscaler.to_gpu()
downscaler.to_gpu()
# Setup an optimizer
def make_optimizer(model, alpha=0.0002, beta1=0.5):
optimizer = chainer.optimizers.Adam(alpha=alpha, beta1=beta1)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.00001), 'hook_dec')
return optimizer
opt_gen_up = make_optimizer(upscaler.gen)
opt_dis_up = make_optimizer(upscaler.dis)
opt_gen_down = make_optimizer(downscaler.gen)
opt_dis_down = make_optimizer(downscaler.dis)
train_l_d = AutoUpscaleDataset(
"{}/trainA".format(args.dataset),
random_nn=True,
)
train_s_d = Single32Dataset("{}/trainB".format(args.dataset), )
test_l_d = AutoUpscaleDataset(
"{}/trainA".format(args.dataset),
random_nn=False,
)
test_s_d = Single32Dataset("{}/trainB".format(args.dataset), )
train_l_iter = chainer.iterators.SerialIterator(train_l_d, args.batchsize)
test_l_iter = chainer.iterators.SerialIterator(test_l_d, 1)
train_s_iter = chainer.iterators.SerialIterator(train_s_d, args.batchsize)
test_s_iter = chainer.iterators.SerialIterator(test_s_d, 1)
# Set up a trainer
updater = CycleUpdater(
upscaler=upscaler,
downscaler=downscaler,
iterator={
'main': train_l_iter,
'trainB': train_s_iter,
'testA': test_l_iter,
'testB': test_s_iter,
},
optimizer={
'gen_up': opt_gen_up,
'dis_up': opt_dis_up,
'gen_down': opt_gen_down,
'dis_down': opt_dis_down,
},
device=args.gpu,
)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
snapshot_interval = (args.snapshot_interval, 'iteration')
display_interval = (args.display_interval, 'iteration')
preview_interval = (args.preview_interval, 'iteration')
trainer.extend(
extensions.snapshot(filename='snapshot_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval,
)
logging_keys = []
trainer.extend(
extensions.snapshot_object(upscaler.gen,
'gen_up_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval,
)
trainer.extend(
extensions.snapshot_object(upscaler.dis,
'dis_up_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval,
)
logging_keys += [
'gen_up/loss_adv',
'gen_up/loss_rec',
'dis_up/loss_real',
'dis_up/loss_fake',
]
trainer.extend(
extensions.snapshot_object(downscaler.gen,
'gen_down_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval,
)
trainer.extend(
extensions.snapshot_object(downscaler.dis,
'dis_down_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval,
)
logging_keys += [
'gen_down/loss_adv',
'gen_down/loss_rec',
'dis_down/loss_real',
'dis_down/loss_fake',
]
trainer.extend(extensions.LogReport(trigger=preview_interval))
trainer.extend(
extensions.PlotReport(
logging_keys,
trigger=preview_interval,
))
trainer.extend(extensions.PrintReport(['epoch', 'iteration'] +
logging_keys, ),
trigger=display_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.extend(out_image_cycle(upscaler.gen, downscaler.gen, 8, args.out),
trigger=preview_interval)
trainer.extend(CommandsExtension())
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
def main():
parser = argparse.ArgumentParser(description='Chainer CIFAR example:')
parser.add_argument('--seed',
'-s',
type=int,
default=0,
help='seed for random values')
parser.add_argument('--dataset',
'-d',
default='cifar10',
help='The dataset to use: cifar10 or cifar100')
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.01,
help='Learning rate for SGD')
parser.add_argument('--epoch',
'-e',
type=int,
default=300,
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('--out',
'-o',
default='result',
help='Directory to output the result')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the training from snapshot')
parser.add_argument('--aug_method',
'-a',
default='random_erasing',
choices=['none', 'mixup', 'random_erasing', 'both'],
help='data augmentation strategy')
parser.add_argument('--model',
'-m',
default='pyramid',
choices=['resnet50', 'pyramid'],
help='data augmentation strategy')
parser.add_argument('--weights', '-w', default='', help='initial weight')
parser.add_argument('--consistent_weight', default=10)
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print(args)
print('')
set_random_seed(args.seed)
# Set up a neural network to train.
# Classifier reports softmax cross entropy loss and accuracy at every
# iteration, which will be used by the PrintReport extension below.
if args.dataset == 'cifar10':
print('Using CIFAR10 dataset.')
class_labels = 10
# trainのうち10000枚を検証用にとっておく. splitと呼ぶ
# testの10000枚はラベルを-1に変換して、ラベルなしのデータとして扱う. unlabeledと呼ぶ
# 1. testに対して、精度があがるのか?
# 2. splitで、精度の向上と連動した様子が観察できるのか？
train, test = get_cifar10()
split = train[-10000:]
train = train[:-10000]
# label = -1のデータとして扱う
unlabeled = [(x[0], -1) for x in test]
print(
f'train:{len(train)}, unlabeled:{len(unlabeled)}, test:{len(test)}'
)
train = chainer.datasets.ConcatenatedDataset(train, unlabeled)
elif args.dataset == 'cifar100':
print('Using CIFAR100 dataset.')
class_labels = 100
train, test = get_cifar100()
else:
raise RuntimeError('Invalid dataset choice.')
if args.model == 'resnet50':
predictor = ResNet(None)
predictor.fc6 = L.Linear(2048, class_labels)
predictor.fc6.name = 'fc6'
predictor2 = ResNet(None)
predictor2.fc6 = L.Linear(2048, class_labels)
predictor2.fc6.name = 'fc6'
elif args.model == 'pyramid':
predictor = shaked_pyramid_net.PyramidNet(skip=True)
if not args.weights == '':
print(f'loading weights from {args.weights}')
chainer.serializers.load_npz(args.weights, predictor)
chainer.serializers.load_npz(args.weights, predictor2)
model = mean_teacher_train_chain.MeanTeacherTrainChain(
predictor, predictor2, args.consistent_weight)
if args.gpu >= 0:
# Make a specified GPU current
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu() # Copy the model to the GPU
model.teacher.to_gpu()
optimizer = chainer.optimizers.MomentumSGD(args.learnrate)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(5e-4))
# augment train data
print('currently, aug_method is ignored')
train = dataset.SingleCifar10((train, None))
train = chainer.datasets.transform_dataset.TransformDataset(
train, transformer.LessonTransform(crop_size=(32, 32)))
train_iter = chainer.iterators.SerialIterator(train,
args.batchsize,
shuffle=True)
split_iter = chainer.iterators.SerialIterator(split,
args.batchsize,
repeat=False,
shuffle=False)
test_iter = chainer.iterators.SerialIterator(test,
args.batchsize,
repeat=False,
shuffle=False)
# Set up a trainer
updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
# teacherをupdateするためのextension
def update_teacher(trainer):
model.on_update_finished(trainer)
trainer.extend(update_teacher)
# Evaluate the model with the test dataset for each epoch
eval_trigger = (1, 'epoch')
classifier = chainer.links.Classifier(model.teacher)
split_evaluator = extensions.Evaluator(split_iter,
classifier,
device=args.gpu)
split_evaluator.name = 'observable_validation'
trainer.extend(split_evaluator, trigger=eval_trigger)
truth_evaluator = extensions.Evaluator(test_iter,
classifier,
device=args.gpu)
truth_evaluator.name = 'truth_validation'
trainer.extend(truth_evaluator, trigger=eval_trigger)
# Reduce the learning rate by half every 25 epochs.
lr_drop_epoch = [int(args.epoch * 0.5), int(args.epoch * 0.75)]
lr_drop_ratio = 0.1
print(f'lr schedule: {lr_drop_ratio}, timing: {lr_drop_epoch}')
def lr_drop(trainer):
trainer.updater.get_optimizer('main').lr *= lr_drop_ratio
trainer.extend(lr_drop,
trigger=chainer.training.triggers.ManualScheduleTrigger(
lr_drop_epoch, 'epoch'))
trainer.extend(extensions.observe_lr(), trigger=(1, 'epoch'))
# Dump a computational graph from 'loss' variable at the first iteration
# The "main" refers to the target link of the "main" optimizer.
trainer.extend(extensions.dump_graph('main/loss'))
# Take a snapshot at each epoch
#trainer.extend(extensions.snapshot(), trigger=(args.epoch, 'epoch'))
trainer.extend(extensions.snapshot_object(model,
'observable_best_accuracy.npz'),
trigger=chainer.training.triggers.MaxValueTrigger(
'observable_validation/main/accuracy'))
trainer.extend(extensions.snapshot_object(model,
'truth_best_accuracy.npz'),
trigger=chainer.training.triggers.MaxValueTrigger(
'truth_validation/main/accuracy'))
# Write a log of evaluation statistics for each epoch
trainer.extend(extensions.LogReport())
# Print selected entries of the log to stdout
# Here "main" refers to the target link of the "main" optimizer again, and
# "validation" refers to the default name of the Evaluator extension.
# Entries other than 'epoch' are reported by the Classifier link, called by
# either the updater or the evaluator.
trainer.extend(
extensions.PrintReport([
'epoch', 'lr', 'main/class_loss', 'main/consistency_loss',
'main/loss', 'main/teacher_accuracy', 'main/student_accuracy',
'observable_validation/main/loss',
'observable_validation/main/accuracy',
'truth_validation/main/accuracy', 'truth_validation/main/loss',
'elapsed_time'
]))
# Print a progress bar to stdout
trainer.extend(extensions.ProgressBar())
# interact with chainerui
trainer.extend(CommandsExtension(), trigger=(100, 'iteration'))
# save args
save_args(args, args.out)
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# trainer.extend(extensions.dump_graph('main/loss'))
# Run the training
trainer.run()
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('--gpu0',
'-g',
type=int,
default=0,
help='GPU1 ID (negative value indicates CPU)')
parser.add_argument('--gpu1',
'-G',
type=int,
default=2,
help='GPU2 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='loading dataset from disk')
parser.add_argument('--opt',
'-o',
type=str,
choices=('adam', 'sgd'),
default='adam')
parser.add_argument('--fsize', '-f', type=int, default=5)
parser.add_argument('--ch', '-c', type=int, default=4)
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("# Filter Size: {}".format(args.fsize))
print("# Channel Scale: {}".format(args.ch))
print('# Train Dataet: General 100')
if args.iter_parallel:
print("# Data Iters that loads in Parallel")
print("\n")
# 保存ディレクトリ
# make result dir
network_name = 'AEFINetConcat'
model_name = 'AEFINet_Test_opt_{}_ch_{}_fsize_{}'.format(
args.opt, args.ch, args.fsize)
outdir = path.join(ROOT_PATH, 'results', 'FI', 'AEFINet', model_name)
util.make_result_dir(args, outdir)
#loading dataset
if args.iter_parallel:
train = datasets.SequenceDataset(
dataset='UCF101_train_size64_frame3_group10_max100_p')
test = datasets.SequenceDataset(
dataset='UCF101_test_size64_frame3_group25_max5_p')
else:
train = datasets.SequenceDatasetOnMem(
dataset='UCF101_train_size64_frame3_group10_max100_p')
test = datasets.SequenceDatasetOnMem(
dataset='UCF101_test_size64_frame3_group25_max5_p')
# prepare model
chainer.cuda.get_device_from_id(args.gpu0).use()
model = N.GenEvaluator(N.AEFINetConcat(f_size=args.fsize, ch=args.ch))
# 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.ParallelUpdater(
train_iter,
optimizer,
devices={
'main': args.gpu0,
'second': args.gpu1
},
)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=outdir)
# # eval test data
trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu0))
# 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'))
elif args.opt == 'adam':
trainer.extend(extensions.ExponentialShift("alpha", 0.1),
trigger=(100, '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/PSNR',
'validation/main/PSNR', 'lr', 'elapsed_time'
]))
# print progbar
trainer.extend(extensions.ProgressBar())
# [ChainerUI] enable to send commands from ChainerUI
trainer.extend(CommandsExtension())
# [ChainerUI] save 'args' to show experimental conditions
save_args(args, outdir)
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# start train
trainer.run()
# save final model
util.save_trained_model(model_name,
model,
network_name,
f_size=args.fsize,
ch=args.ch)
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='GPU1 ID (negative value indicates CPU)')
parser.add_argument('--gpu1',
'-G',
type=int,
default=2,
help='GPU2 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='loading dataset from disk')
parser.add_argument('--test',
action='store_true',
default=False,
help='Test Mode, a few dataset')
parser.add_argument('--opt',
'-o',
type=str,
choices=('adam', 'sgd'),
default='adam')
parser.add_argument('--fsize', '-f', type=int, default=5)
parser.add_argument('--ch', '-c', type=int, default=4)
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("# Filter Size: {}".format(args.fsize))
print("# Channel Scale: {}".format(args.ch))
print('# Train Dataet: General 100')
if args.iter_parallel:
print("# Data Iters that loads in Parallel")
print("\n")
# 保存ディレクトリ
# save didrectory
model_dir_name = 'AEFINet2_opt_{}_ch_{}_fsize_{}'.format(
args.opt, args.ch, args.fsize)
outdir = path.join(ROOT_PATH, 'results', 'FI', 'AEFINet', model_dir_name)
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))
#loading dataset
if args.test:
print(
'# loading test dataet(UCF101_minimam_test_size64_frame3_group2_max4_p) ...'
)
train_dataset = 'UCF101_minimam_test_size64_frame3_group2_max4_p'
test_dataset = 'UCF101_minimam_test_size64_frame3_group2_max4_p'
else:
print(
'# loading test dataet(UCF101_train_size64_frame3_group10_max100_p, UCF101_test_size64_frame3_group25_max5_p) ...'
)
train_dataset = 'UCF101_train_size64_frame3_group10_max100_p'
test_dataset = 'UCF101_test_size64_frame3_group25_max5_p'
if args.iter_parallel:
train = ds.SequenceDataset(dataset=train_dataset)
test = ds.SequenceDataset(dataset=test_dataset)
else:
train = ds.SequenceDatasetOnMem(dataset=train_dataset)
test = ds.SequenceDatasetOnMem(dataset=test_dataset)
# prepare model
# chainer.cuda.get_device_from_id(args.gpu).use()
model = N.AEFINet2(vgg_path=path.join(ROOT_PATH, 'models', 'VGG16.npz'),
f_size=args.fsize,
n_ch=args.ch,
size=64)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
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,
loss_func=model.get_loss_func())
# updater = training.ParallelUpdater(
# train_iter,
# optimizer,
# devices={'main': args.gpu, 'second': args.gpu1},
# loss_func=model.get_loss_func(),
# )
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=outdir)
# # eval test data
trainer.extend(
extensions.Evaluator(test_iter,
model,
device=args.gpu,
eval_func=model.get_loss_func()))
# dump loss graph
trainer.extend(extensions.dump_graph('main/loss'))
# lr shift
if args.opt == 'sgd':
trainer.extend(extensions.ExponentialShift("lr", 0.1),
trigger=(50, 'epoch'))
elif 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/psnr',
'validation/main/psnr', 'lr', 'elapsed_time'
]))
# print progbar
trainer.extend(extensions.ProgressBar())
# [ChainerUI] enable to send commands from ChainerUI
trainer.extend(CommandsExtension())
# [ChainerUI] save 'args' to show experimental conditions
save_args(args, outdir)
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
trainer.run()
# save final model
model_outdir = path.join(ROOT_PATH, 'models', model_dir_name)
if not path.exists(model_outdir):
os.makedirs(model_outdir)
model_name = 'AEFINet2_{}_ch_{}_fsize_{}.npz'.format(
args.opt, args.ch, args.fsize)
chainer.serializers.save_npz(path.join(model_outdir, model_name), model)
model_parameter = {
'name': 'AEFINetConcat',
'parameter': {
'f_size': args.fsize,
'ch': args.ch
}
}
with open(path.join(model_outdir, 'model_parameter.json'), 'w') as f:
json.dump(model_parameter, f)
def main():
parser = argparse.ArgumentParser(
description='chainer implementation of model', )
parser.add_argument(
'--batchsize',
'-b',
type=int,
default=1,
help='Number of images in each mini-batch',
)
parser.add_argument(
'--epoch',
'-e',
type=int,
default=200,
help='Number of sweeps over the dataset to train',
)
parser.add_argument(
'--base_ch',
type=int,
default=64,
help='base channel size of hidden layer',
)
parser.add_argument(
'--gpu',
'-g',
type=int,
default=-1,
help='GPU ID (negative value indicates CPU)',
)
parser.add_argument(
'--dataset',
'-i',
default='./image/fsm',
help='Directory of image files.',
)
parser.add_argument(
'--out',
'-o',
default='result',
help='Directory to output the result',
)
parser.add_argument(
'--resume',
'-r',
default='',
help='Resume the training from snapshot',
)
parser.add_argument(
'--snapshot_interval',
type=int,
default=1000,
help='Interval of snapshot',
)
parser.add_argument(
'--display_interval',
type=int,
default=10,
help='Interval of displaying log to console',
)
parser.add_argument(
'--preview_interval',
type=int,
default=100,
help='Interval of previewing generated image',
)
parser.add_argument(
'--use_random_nn_downscale',
action='store_true',
default=False,
help='downscal by sampling 4-nearest pixel randomly',
)
parser.add_argument(
'--flat_discriminator',
action='store_true',
default=False,
help='(deprecated)',
)
parser.add_argument(
'--composite',
action='store_true',
default=False,
help='composite',
)
args = parser.parse_args()
save_args(args, args.out)
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
model = Pix2Pix(in_ch=4,
out_ch=4,
base_ch=args.base_ch,
flat=args.flat_discriminator)
gen = model.gen
dis = model.dis
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use() # Make a specified GPU current
model.to_gpu() # Copy the model to the GPU
# Setup an optimizer
def make_optimizer(model, alpha=0.0002, beta1=0.5):
optimizer = chainer.optimizers.Adam(alpha=alpha, beta1=beta1)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.00001), 'hook_dec')
return optimizer
opt_gen = make_optimizer(gen)
opt_dis = make_optimizer(dis)
print('# upscale learning with automatically generated images')
if args.composite:
train_d = CompositeAutoUpscaleDataset(args.dataset, )
test_d = CompositeAutoUpscaleDataset(args.dataset, )
else:
train_d = AutoUpscaleDataset(
"{}/main".format(args.dataset),
random_nn=args.use_random_nn_downscale,
)
test_d = AutoUpscaleDataset(
"{}/main".format(args.dataset),
random_nn=False,
)
train_iter = chainer.iterators.SerialIterator(train_d, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test_d, args.batchsize)
# Set up a trainer
updater = Pix2PixUpdater(
model=model,
iterator={
'main': train_iter,
},
optimizer={
'gen': opt_gen,
'dis': opt_dis,
},
device=args.gpu,
)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
snapshot_interval = (args.snapshot_interval, 'iteration')
display_interval = (args.display_interval, 'iteration')
preview_interval = (args.preview_interval, 'iteration')
trainer.extend(
extensions.snapshot(filename='snapshot_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval,
)
trainer.extend(
extensions.snapshot_object(model.gen,
'gen_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval,
)
trainer.extend(
extensions.snapshot_object(model.dis,
'dis_iter_{.updater.iteration}.npz'),
trigger=snapshot_interval,
)
trainer.extend(extensions.LogReport(trigger=display_interval))
trainer.extend(
extensions.PlotReport(
[
'gen/loss_adv',
'gen/loss_rec',
'gen/loss',
'dis/loss',
],
trigger=display_interval,
))
trainer.extend(extensions.PrintReport([
'epoch',
'iteration',
'gen/loss_adv',
'gen/loss_rec',
'gen/loss',
'dis/loss',
]),
trigger=display_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
upscaler = Upscaler(ChainerConverter(gen, 64), batch_size=args.batchsize)
trainer.extend(out_image(test_iter, gen, 10, args.out),
trigger=display_interval)
trainer.extend(full_out_image(upscaler, "{}/test".format(args.dataset),
args.out),
trigger=preview_interval)
trainer.extend(CommandsExtension())
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
def main():
parser = argparse.ArgumentParser(description='Train Deblur Network')
parser.add_argument('--seed',
'-s',
type=int,
default=0,
help='seed for random values')
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.1,
help='Learning rate for SGD')
parser.add_argument('--epoch',
'-e',
type=int,
default=50,
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('--out',
'-o',
default='result',
help='Directory to output the result')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the training from snapshot')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print(args)
print('')
set_random_seed(args.seed)
predictor = srcnn.create_srcnn()
model = L.Classifier(predictor, lossfun=F.mean_squared_error, accfun=psnr)
if args.gpu >= 0:
# Make a specified GPU current
chainer.backends.cuda.get_device_from_id(args.gpu).use()
model.to_gpu() # Copy the model to the GPU
optimizer = chainer.optimizers.MomentumSGD(args.learnrate)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(5e-4))
base_dir = 'data/blurred_sharp'
train_data = pairwise_dataset.PairwiseDataset(
blur_image_list=str(Path(base_dir).joinpath('train_blur_images.txt')),
sharp_image_list=str(
Path(base_dir).joinpath('train_sharp_images.txt')),
root=base_dir)
train_data = chainer.datasets.TransformDataset(train_data,
transform.Transform())
test_data = pairwise_dataset.PairwiseDataset(
blur_image_list=str(Path(base_dir).joinpath('test_blur_images.txt')),
sharp_image_list=str(Path(base_dir).joinpath('test_sharp_images.txt')),
root=base_dir)
# 普通はTransformしないような気がするけど、解像度がかわっちゃうのがなー
test_data = chainer.datasets.TransformDataset(test_data,
transform.Transform())
train_iter = chainer.iterators.SerialIterator(train_data, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test_data,
args.batchsize,
repeat=False,
shuffle=False)
# Set up a trainer
updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
trainer.extend(extensions.FailOnNonNumber())
# Evaluate the model with the test dataset for each epoch
eval_trigger = (1, 'epoch')
trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu),
trigger=eval_trigger)
# Reduce the learning rate by half every 25 epochs.
lr_drop_epoch = [int(args.epoch * 0.5), int(args.epoch * 0.75)]
lr_drop_ratio = 0.1
print('lr schedule: {}, timing: {}'.format(lr_drop_ratio, lr_drop_epoch))
def lr_drop(trainer):
trainer.updater.get_optimizer('main').lr *= lr_drop_ratio
trainer.extend(lr_drop,
trigger=chainer.training.triggers.ManualScheduleTrigger(
lr_drop_epoch, 'epoch'))
trainer.extend(extensions.observe_lr(), trigger=(1, 'epoch'))
# Dump a computational graph from 'loss' variable at the first iteration
# The "main" refers to the target link of the "main" optimizer.
trainer.extend(extensions.dump_graph('main/loss'))
# Take a snapshot at each epoch
trainer.extend(extensions.snapshot(model.predictor,
'model_{.updater.epoch}.npz'),
trigger=(1, 'epoch'))
# Write a log of evaluation statistics for each epoch
trainer.extend(extensions.LogReport(trigger=(100, 'iteration')))
# Print selected entries of the log to stdout
# Here "main" refers to the target link of the "main" optimizer again, and
# "validation" refers to the default name of the Evaluator extension.
# Entries other than 'epoch' are reported by the Classifier link, called by
# either the updater or the evaluator.
trainer.extend(extensions.PrintReport([
'epoch', 'lr', 'main/loss', 'validation/main/loss', 'main/accuracy',
'validation/main/accuracy', 'elapsed_time'
]),
trigger=(100, 'iteration'))
# Print a progress bar to stdout
trainer.extend(extensions.ProgressBar())
# interact with chainerui
trainer.extend(CommandsExtension(), trigger=(100, 'iteration'))
# save args
save_args(args, args.out)
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
def main():
# command line argument parsing
parser = argparse.ArgumentParser(
description='Multi-Perceptron classifier/regressor')
parser.add_argument('dataset', help='Path to data file')
parser.add_argument('--activation',
'-a',
choices=activ.keys(),
default='sigmoid',
help='Activation function')
parser.add_argument('--batchsize',
'-b',
type=int,
default=10,
help='Number of samples in each mini-batch')
parser.add_argument('--dropout_ratio',
'-dr',
type=float,
default=0,
help='dropout ratio')
parser.add_argument('--epoch',
'-e',
type=int,
default=100,
help='Number of sweeps over the dataset to train')
parser.add_argument('--snapshot',
'-s',
type=int,
default=-1,
help='snapshot interval')
parser.add_argument('--labelcol',
'-l',
type=int,
nargs="*",
default=[0, 1, 2, 3],
help='column indices of target variables')
parser.add_argument('--initmodel',
'-i',
help='Initialize the model from given file')
parser.add_argument('--gpu',
'-g',
type=int,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--outdir',
'-o',
default='result',
help='Directory to output the result')
parser.add_argument(
'--optimizer',
'-op',
default='MomentumSGD',
help='optimizer {MomentumSGD,AdaDelta,AdaGrad,Adam,RMSprop}')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the training from snapshot')
parser.add_argument('--skip_rows',
'-sr',
type=int,
default=0,
help='num of rows skipped in the data')
parser.add_argument(
'--skip_column',
'-sc',
type=int,
nargs="*",
default=[],
help='set of indices of columns to be skipped in the data')
parser.add_argument('--unit',
'-nu',
type=int,
nargs="*",
default=[128, 64, 32, 4],
help='Number of units in the hidden layers')
parser.add_argument(
'--test_every',
'-t',
type=int,
default=5,
help='use one in every ? entries in the dataset for validation')
parser.add_argument('--regression',
action='store_true',
help="set for regression, otherwise classification")
parser.add_argument('--batchnorm',
'-bn',
action='store_true',
help="perform batchnormalization")
parser.add_argument('--predict', action='store_true')
parser.add_argument('--weight_decay',
'-w',
type=float,
default=1e-5,
help='weight decay for regularization')
args = parser.parse_args()
##
if not args.gpu:
if chainer.cuda.available:
args.gpu = 0
else:
args.gpu = -1
print('GPU: {} Minibatch-size: {} # epoch: {}'.format(
args.gpu, args.batchsize, args.epoch))
# Set up a neural network to train
model = MLP(args)
if args.initmodel:
print('Load model from: ', args.initmodel)
chainer.serializers.load_npz(args.initmodel, model)
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use() # Make a specified GPU current
model.to_gpu() # Copy the model to the GPU
# Set up an optimizer
if args.optimizer == 'MomentumSGD':
optimizer = chainer.optimizers.MomentumSGD(lr=0.01, momentum=0.9)
elif args.optimizer == 'AdaDelta':
optimizer = chainer.optimizers.AdaDelta(rho=0.95, eps=1e-06)
elif args.optimizer == 'AdaGrad':
optimizer = chainer.optimizers.AdaGrad(lr=0.01, eps=1e-08)
elif args.optimizer == 'Adam':
optimizer = chainer.optimizers.Adam(alpha=0.01,
beta1=0.9,
beta2=0.999,
eps=1e-08)
elif args.optimizer == 'RMSprop':
optimizer = chainer.optimizers.RMSprop(lr=0.01, alpha=0.99, eps=1e-08)
else:
print("Wrong optimiser")
exit(-1)
optimizer.setup(model)
if args.weight_decay > 0:
optimizer.add_hook(chainer.optimizer.WeightDecay(args.weight_decay))
print(
'units: {}, optimiser: {}, Weight decay: {}, dropout ratio: {}'.format(
args.unit, args.optimizer, args.weight_decay, args.dropout_ratio))
# select numpy or cupy
xp = chainer.cuda.cupy if args.gpu >= 0 else np
label_type = np.float32 if args.regression else np.int32
# read csv file
csvdata = np.loadtxt(args.dataset, delimiter=",", skiprows=args.skip_rows)
ind = np.ones(csvdata.shape[1], dtype=bool) # indices for unused columns
ind[args.labelcol] = False
for i in args.skip_column:
ind[i] = False
x = np.array(csvdata[:, ind], dtype=np.float32)
t = csvdata[:, args.labelcol]
t = np.array(t, dtype=label_type)
if not args.regression:
t = t[:, 0]
print('target column: {}, excluded columns: {}'.format(
args.labelcol,
np.where(ind == False)[0].tolist()))
print("variable shape: {}, label shape: {}, label type: {}".format(
x.shape, t.shape, label_type))
## train-validation data
# random spliting
#train, test = datasets.split_dataset_random(datasets.TupleDataset(x, t), int(0.8*t.size))
# splitting by modulus of index
train_idx = [i for i in range(len(t)) if (i + 1) % args.test_every != 0]
var_idx = [i for i in range(len(t)) if (i + 1) % args.test_every == 0]
n = len(train_idx)
train_idx.extend(var_idx)
train, test = datasets.split_dataset(datasets.TupleDataset(x, t), n,
train_idx)
# dataset iterator
train_iter = iterators.SerialIterator(train, args.batchsize, shuffle=True)
test_iter = iterators.SerialIterator(test,
args.batchsize,
repeat=False,
shuffle=False)
updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.outdir)
frequency = args.epoch if args.snapshot == -1 else max(1, args.snapshot)
log_interval = 1, 'epoch'
val_interval = frequency / 10, 'epoch'
trainer.extend(
extensions.snapshot(filename='snapshot_epoch_{.updater.epoch}'),
trigger=(frequency, 'epoch'))
trainer.extend(extensions.snapshot_object(model,
'model_epoch_{.updater.epoch}'),
trigger=(frequency / 5, 'epoch'))
trainer.extend(extensions.LogReport(trigger=log_interval))
trainer.extend(extensions.dump_graph('main/loss'))
if args.optimizer in ['MomentumSGD', 'AdaGrad', 'RMSprop']:
trainer.extend(extensions.observe_lr(), trigger=log_interval)
trainer.extend(extensions.ExponentialShift('lr', 0.5),
trigger=(args.epoch / 5, 'epoch'))
if extensions.PlotReport.available():
trainer.extend(
extensions.PlotReport(['main/loss', 'validation/main/loss'],
'epoch',
file_name='loss.png'))
trainer.extend(
extensions.PlotReport(
['main/accuracy', 'validation/main/accuracy'],
'epoch',
file_name='accuracy.png'))
trainer.extend(extensions.PrintReport([
'epoch', 'main/loss', 'main/accuracy', 'validation/main/loss',
'validation/main/accuracy', 'elapsed_time', 'lr'
]),
trigger=log_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
if args.resume:
chainer.serializers.load_npz(args.resume, trainer)
# ChainerUI
trainer.extend(CommandsExtension())
save_args(args, args.outdir)
trainer.extend(extensions.LogReport(trigger=log_interval))
if not args.predict:
trainer.run()
else:
test = datasets.TupleDataset(x, t)
## prediction
print("predicting: {} entries...".format(len(test)))
x, t = chainer.dataset.concat_examples(test, args.gpu)
with chainer.using_config('train', False):
y = model(x, t)
if args.gpu >= 0:
pred = chainer.cuda.to_cpu(y.data)
t = chainer.cuda.to_cpu(t)
else:
pred = y.data
if args.regression:
left = np.arange(t.shape[0])
for i in range(len(args.labelcol)):
rmse = F.mean_squared_error(pred[:, i], t[:, i])
plt.plot(left, t[:, i], color="royalblue")
plt.plot(left, pred[:, i], color="crimson", linestyle="dashed")
plt.title("RMSE: {}".format(np.sqrt(rmse.data)))
plt.savefig(args.outdir + '/result{}.png'.format(i))
plt.close()
result = np.hstack((t, pred))
np.savetxt(args.outdir + "/result.csv",
result,
fmt='%1.5f',
delimiter=",",
header="truth,prediction")
else:
p = np.argmax(pred, axis=1)
result = np.vstack((t, p)).astype(np.int32).transpose()
print(result.tolist())
np.savetxt(args.outdir + "/result.csv",
result,
delimiter=",",
header="truth,prediction")
