Python chainer.training.extensions.snapshot_object() Examples
The following are 15
code examples of chainer.training.extensions.snapshot_object().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
chainer.training.extensions
, or try the search function
.
.
Example #1
| Source File: test_snapshot.py From chainer with MIT License | 6 votes |
|
def test_on_error(self):
class TheOnlyError(Exception):
pass
@training.make_extension(trigger=(1, 'iteration'), priority=100)
def exception_raiser(trainer):
raise TheOnlyError()
self.trainer.extend(exception_raiser)
snapshot = extensions.snapshot_object(self.trainer, self.filename,
snapshot_on_error=True)
self.trainer.extend(snapshot)
self.assertFalse(os.path.exists(self.filename))
with self.assertRaises(TheOnlyError):
self.trainer.run()
self.assertTrue(os.path.exists(self.filename))
Example #2
| Source File: train.py From qb with MIT License | 5 votes |
|
def main(model):
train = read_data(fold=BUZZER_TRAIN_FOLD)
valid = read_data(fold=BUZZER_DEV_FOLD)
print('# train data: {}'.format(len(train)))
print('# valid data: {}'.format(len(valid)))
train_iter = chainer.iterators.SerialIterator(train, 64)
valid_iter = chainer.iterators.SerialIterator(valid, 64, repeat=False, shuffle=False)
optimizer = chainer.optimizers.Adam()
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(1e-4))
updater = training.updaters.StandardUpdater(train_iter, optimizer, converter=convert_seq, device=0)
trainer = training.Trainer(updater, (20, 'epoch'), out=model.model_dir)
trainer.extend(extensions.Evaluator(valid_iter, model, converter=convert_seq, device=0))
record_trigger = training.triggers.MaxValueTrigger('validation/main/accuracy', (1, 'epoch'))
trainer.extend(extensions.snapshot_object(model, 'buzzer.npz'), trigger=record_trigger)
trainer.extend(extensions.LogReport())
trainer.extend(extensions.ProgressBar())
trainer.extend(extensions.PrintReport([
'epoch', 'main/loss', 'validation/main/loss',
'main/accuracy', 'validation/main/accuracy', 'elapsed_time'
]))
if not os.path.isdir(model.model_dir):
os.mkdir(model.model_dir)
trainer.run()
Example #3
| Source File: test_snapshot.py From chainer with MIT License | 5 votes |
|
def test_savefun_and_writer_exclusive(self):
# savefun and writer arguments cannot be specified together.
def savefun(*args, **kwargs):
assert False
writer = extensions.snapshot_writers.SimpleWriter()
with pytest.raises(TypeError):
extensions.snapshot(savefun=savefun, writer=writer)
trainer = mock.MagicMock()
with pytest.raises(TypeError):
extensions.snapshot_object(trainer, savefun=savefun, writer=writer)
Example #4
| Source File: test_snapshot.py From chainer with MIT License | 5 votes |
|
def test_save_file(self):
w = extensions.snapshot_writers.SimpleWriter()
snapshot = extensions.snapshot_object(self.trainer, 'myfile.dat',
writer=w)
snapshot(self.trainer)
self.assertTrue(os.path.exists('myfile.dat'))
Example #5
| Source File: test_snapshot.py From chainer with MIT License | 5 votes |
|
def test_clean_up_tempdir(self):
snapshot = extensions.snapshot_object(self.trainer, 'myfile.dat')
snapshot(self.trainer)
left_tmps = [fn for fn in os.listdir('.')
if fn.startswith('tmpmyfile.dat')]
self.assertEqual(len(left_tmps), 0)
Example #6
| Source File: train_ch.py From imgclsmob with MIT License | 4 votes |
|
def prepare_trainer(net,
optimizer_name,
lr,
momentum,
num_epochs,
train_data,
val_data,
logging_dir_path,
use_gpus):
if optimizer_name == "sgd":
optimizer = chainer.optimizers.MomentumSGD(lr=lr, momentum=momentum)
elif optimizer_name == "nag":
optimizer = chainer.optimizers.NesterovAG(lr=lr, momentum=momentum)
else:
raise Exception("Unsupported optimizer: {}".format(optimizer_name))
optimizer.setup(net)
# devices = tuple(range(num_gpus)) if num_gpus > 0 else (-1, )
devices = (0,) if use_gpus else (-1,)
updater = training.updaters.StandardUpdater(
iterator=train_data["iterator"],
optimizer=optimizer,
device=devices[0])
trainer = training.Trainer(
updater=updater,
stop_trigger=(num_epochs, "epoch"),
out=logging_dir_path)
val_interval = 100000, "iteration"
log_interval = 1000, "iteration"
trainer.extend(
extension=extensions.Evaluator(
iterator=val_data["iterator"],
target=net,
device=devices[0]),
trigger=val_interval)
trainer.extend(extensions.dump_graph("main/loss"))
trainer.extend(extensions.snapshot(), trigger=val_interval)
trainer.extend(
extensions.snapshot_object(
net,
"model_iter_{.updater.iteration}"),
trigger=val_interval)
trainer.extend(extensions.LogReport(trigger=log_interval))
trainer.extend(extensions.observe_lr(), trigger=log_interval)
trainer.extend(
extensions.PrintReport([
"epoch", "iteration", "main/loss", "validation/main/loss", "main/accuracy", "validation/main/accuracy",
"lr"]),
trigger=log_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
return trainer
Example #7
| Source File: train_ch_cifar.py From imgclsmob with MIT License | 4 votes |
|
def prepare_trainer(net,
optimizer_name,
lr,
momentum,
num_epochs,
train_iter,
val_iter,
logging_dir_path,
num_gpus=0):
if optimizer_name == "sgd":
optimizer = chainer.optimizers.MomentumSGD(lr=lr, momentum=momentum)
elif optimizer_name == "nag":
optimizer = chainer.optimizers.NesterovAG(lr=lr, momentum=momentum)
else:
raise Exception('Unsupported optimizer: {}'.format(optimizer_name))
optimizer.setup(net)
# devices = tuple(range(num_gpus)) if num_gpus > 0 else (-1, )
devices = (0,) if num_gpus > 0 else (-1,)
updater = training.updaters.StandardUpdater(
iterator=train_iter,
optimizer=optimizer,
device=devices[0])
trainer = training.Trainer(
updater=updater,
stop_trigger=(num_epochs, 'epoch'),
out=logging_dir_path)
val_interval = 100000, 'iteration'
log_interval = 1000, 'iteration'
trainer.extend(
extension=extensions.Evaluator(
val_iter,
net,
device=devices[0]),
trigger=val_interval)
trainer.extend(extensions.dump_graph('main/loss'))
trainer.extend(extensions.snapshot(), trigger=val_interval)
trainer.extend(
extensions.snapshot_object(
net,
'model_iter_{.updater.iteration}'),
trigger=val_interval)
trainer.extend(extensions.LogReport(trigger=log_interval))
trainer.extend(extensions.observe_lr(), trigger=log_interval)
trainer.extend(
extensions.PrintReport([
'epoch', 'iteration', 'main/loss', 'validation/main/loss', 'main/accuracy', 'validation/main/accuracy',
'lr']),
trigger=log_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
return trainer
Example #8
| Source File: train_ch_in1k.py From imgclsmob with MIT License | 4 votes |
|
def prepare_trainer(net,
optimizer_name,
lr,
momentum,
num_epochs,
train_iter,
val_iter,
logging_dir_path,
num_gpus=0):
if optimizer_name == "sgd":
optimizer = chainer.optimizers.MomentumSGD(lr=lr, momentum=momentum)
elif optimizer_name == "nag":
optimizer = chainer.optimizers.NesterovAG(lr=lr, momentum=momentum)
else:
raise Exception('Unsupported optimizer: {}'.format(optimizer_name))
optimizer.setup(net)
# devices = tuple(range(num_gpus)) if num_gpus > 0 else (-1, )
devices = (0,) if num_gpus > 0 else (-1,)
updater = training.updaters.StandardUpdater(
iterator=train_iter,
optimizer=optimizer,
device=devices[0])
trainer = training.Trainer(
updater=updater,
stop_trigger=(num_epochs, 'epoch'),
out=logging_dir_path)
val_interval = 100000, 'iteration'
log_interval = 1000, 'iteration'
trainer.extend(
extension=extensions.Evaluator(
val_iter,
net,
device=devices[0]),
trigger=val_interval)
trainer.extend(extensions.dump_graph('main/loss'))
trainer.extend(extensions.snapshot(), trigger=val_interval)
trainer.extend(
extensions.snapshot_object(
net,
'model_iter_{.updater.iteration}'),
trigger=val_interval)
trainer.extend(extensions.LogReport(trigger=log_interval))
trainer.extend(extensions.observe_lr(), trigger=log_interval)
trainer.extend(
extensions.PrintReport([
'epoch', 'iteration', 'main/loss', 'validation/main/loss', 'main/accuracy', 'validation/main/accuracy',
'lr']),
trigger=log_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
return trainer
Example #9
| Source File: chainer_model.py From char-rnn-text-generation with MIT License | 4 votes |
|
def train_main(args):
"""
trains model specfied in args.
main method for train subcommand.
"""
# load text
with open(args.text_path) as f:
text = f.read()
logger.info("corpus length: %s.", len(text))
# data iterator
data_iter = DataIterator(text, args.batch_size, args.seq_len)
# load or build model
if args.restore:
logger.info("restoring model.")
load_path = args.checkpoint_path if args.restore is True else args.restore
model = load_model(load_path)
else:
net = Network(vocab_size=VOCAB_SIZE,
embedding_size=args.embedding_size,
rnn_size=args.rnn_size,
num_layers=args.num_layers,
drop_rate=args.drop_rate)
model = L.Classifier(net)
# make checkpoint directory
log_dir = make_dirs(args.checkpoint_path)
with open("{}.json".format(args.checkpoint_path), "w") as f:
json.dump(model.predictor.args, f, indent=2)
chainer.serializers.save_npz(args.checkpoint_path, model)
logger.info("model saved: %s.", args.checkpoint_path)
# optimizer
optimizer = chainer.optimizers.Adam(alpha=args.learning_rate)
optimizer.setup(model)
# clip gradient norm
optimizer.add_hook(chainer.optimizer.GradientClipping(args.clip_norm))
# trainer
updater = BpttUpdater(data_iter, optimizer)
trainer = chainer.training.Trainer(updater, (args.num_epochs, 'epoch'), out=log_dir)
trainer.extend(extensions.snapshot_object(model, filename=os.path.basename(args.checkpoint_path)))
trainer.extend(extensions.ProgressBar(update_interval=1))
trainer.extend(extensions.LogReport())
trainer.extend(extensions.PlotReport(y_keys=["main/loss"]))
trainer.extend(LoggerExtension(text))
# training start
model.predictor.reset_state()
logger.info("start of training.")
time_train = time.time()
trainer.run()
# training end
duration_train = time.time() - time_train
logger.info("end of training, duration: %ds.", duration_train)
# generate text
seed = generate_seed(text)
generate_text(model, seed, 1024, 3)
return model
Example #10
| Source File: train_fcn32s.py From fcn with MIT License | 4 votes |
|
def get_trainer(optimizer, iter_train, iter_valid, iter_valid_raw,
class_names, args):
model = optimizer.target
updater = chainer.training.StandardUpdater(
iter_train, optimizer, device=args.gpu)
trainer = chainer.training.Trainer(
updater, (args.max_iteration, 'iteration'), out=args.out)
trainer.extend(fcn.extensions.ParamsReport(args.__dict__))
trainer.extend(extensions.ProgressBar(update_interval=5))
trainer.extend(extensions.LogReport(
trigger=(args.interval_print, 'iteration')))
trainer.extend(extensions.PrintReport(
['epoch', 'iteration', 'elapsed_time',
'main/loss', 'validation/main/miou']))
def pred_func(x):
model(x)
return model.score
trainer.extend(
fcn.extensions.SemanticSegmentationVisReport(
pred_func, iter_valid_raw,
transform=fcn.datasets.transform_lsvrc2012_vgg16,
class_names=class_names, device=args.gpu, shape=(4, 2)),
trigger=(args.interval_eval, 'iteration'))
trainer.extend(
chainercv.extensions.SemanticSegmentationEvaluator(
iter_valid, model, label_names=class_names),
trigger=(args.interval_eval, 'iteration'))
trainer.extend(extensions.snapshot_object(
target=model, filename='model_best.npz'),
trigger=chainer.training.triggers.MaxValueTrigger(
key='validation/main/miou',
trigger=(args.interval_eval, 'iteration')))
assert extensions.PlotReport.available()
trainer.extend(extensions.PlotReport(
y_keys=['main/loss'], x_key='iteration',
file_name='loss.png', trigger=(args.interval_print, 'iteration')))
trainer.extend(extensions.PlotReport(
y_keys=['validation/main/miou'], x_key='iteration',
file_name='miou.png', trigger=(args.interval_print, 'iteration')))
return trainer
Example #11
| Source File: train.py From models with MIT License | 4 votes |
|
def train_one_epoch(model, train_data, lr, gpu, batchsize, out):
train_model = PixelwiseSoftmaxClassifier(model)
if gpu >= 0:
# Make a specified GPU current
chainer.cuda.get_device_from_id(gpu).use()
train_model.to_gpu() # Copy the model to the GPU
log_trigger = (0.1, 'epoch')
validation_trigger = (1, 'epoch')
end_trigger = (1, 'epoch')
train_data = TransformDataset(
train_data, ('img', 'label_map'), SimpleDoesItTransform(model.mean))
val = VOCSemanticSegmentationWithBboxDataset(
split='val').slice[:, ['img', 'label_map']]
# Iterator
train_iter = iterators.MultiprocessIterator(train_data, batchsize)
val_iter = iterators.MultiprocessIterator(
val, 1, shuffle=False, repeat=False, shared_mem=100000000)
# Optimizer
optimizer = optimizers.MomentumSGD(lr=lr, momentum=0.9)
optimizer.setup(train_model)
optimizer.add_hook(chainer.optimizer_hooks.WeightDecay(rate=0.0001))
# Updater
updater = training.updaters.StandardUpdater(
train_iter, optimizer, device=gpu)
# Trainer
trainer = training.Trainer(updater, end_trigger, out=out)
trainer.extend(extensions.LogReport(trigger=log_trigger))
trainer.extend(extensions.observe_lr(), trigger=log_trigger)
trainer.extend(extensions.dump_graph('main/loss'))
if extensions.PlotReport.available():
trainer.extend(extensions.PlotReport(
['main/loss'], x_key='iteration',
file_name='loss.png'))
trainer.extend(extensions.PlotReport(
['validation/main/miou'], x_key='iteration',
file_name='miou.png'))
trainer.extend(extensions.snapshot_object(
model, filename='snapshot.npy'),
trigger=end_trigger)
trainer.extend(extensions.PrintReport(
['epoch', 'iteration', 'elapsed_time', 'lr',
'main/loss', 'validation/main/miou',
'validation/main/mean_class_accuracy',
'validation/main/pixel_accuracy']),
trigger=log_trigger)
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.extend(
SemanticSegmentationEvaluator(
val_iter, model,
voc_semantic_segmentation_label_names),
trigger=validation_trigger)
trainer.run()
Example #12
| Source File: demo_nnpu_chainer.py From pywsl with MIT License | 4 votes |
|
def main():
gpu, out = -1, "result"
stepsize = 0.001
batchsize, epoch = 10000, 10
beta, gamma = 0., 1.
data_id, prior = 0, .5
n_p, n_n, n_u, n_t, n_vp, n_vn, n_vu = 100, 0, 10000, 100, 20, 20, 100
data_name, x_p, x_n, x_u, y_u, x_t, y_t, x_vp, x_vn, x_vu, y_vu \
= load_dataset(data_id, n_p, n_n, n_u, prior, n_t, n_vp=n_vp, n_vn=n_vn, n_vu=n_vu)
x_p, x_n, x_u, x_t, x_vp, x_vn, x_vu = x_p.astype(np.float32), x_n.astype(np.float32), \
x_u.astype(np.float32), x_t.astype(np.float32), x_vp.astype(np.float32), \
x_vn.astype(np.float32), x_vu.astype(np.float32),
XYtrain = TupleDataset(np.r_[x_p, x_u], np.r_[np.ones(100), np.zeros(10000)].astype(np.int32))
XYtest = TupleDataset(np.r_[x_vp, x_vu], np.r_[np.ones(20), np.zeros(100)].astype(np.int32))
train_iter = chainer.iterators.SerialIterator(XYtrain, batchsize)
test_iter = chainer.iterators.SerialIterator(XYtest, batchsize, repeat=False, shuffle=False)
loss_type = lambda x: F.sigmoid(-x)
nnpu_risk = PU_Risk(prior, loss=loss_type, nnPU=True, gamma=gamma, beta=beta)
pu_acc = PU_Accuracy(prior)
model = L.Classifier(MLP(), lossfun=nnpu_risk, accfun=pu_acc)
if gpu >= 0:
chainer.backends.cuda.get_device_from_id(gpu).use()
model.to_gpu(gpu)
optimizer = chainer.optimizers.Adam(alpha=stepsize)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.005))
updater = chainer.training.StandardUpdater(train_iter, optimizer, device=gpu)
trainer = chainer.training.Trainer(updater, (epoch, 'epoch'), out=out)
trainer.extend(extensions.LogReport(trigger=(1, 'epoch')))
trainer.extend(extensions.Evaluator(test_iter, model, device=gpu))
trainer.extend(extensions.ProgressBar())
trainer.extend(extensions.PrintReport(
['epoch', 'main/loss', 'validation/main/loss',
'main/accuracy', 'validation/main/accuracy',
'elapsed_time']))
key = 'validation/main/accuracy'
model_name = 'model'
trainer.extend(extensions.snapshot_object(model, model_name),
trigger=chainer.training.triggers.MaxValueTrigger(key))
if extensions.PlotReport.available():
trainer.extend(
extensions.PlotReport(['main/loss', 'validation/main/loss'], 'epoch', file_name=f'loss_curve.png'))
trainer.extend(
extensions.PlotReport(['main/accuracy', 'validation/main/accuracy'],
'epoch', file_name=f'accuracy_curve.png'))
trainer.run()
yh = pred(model, x_t, batchsize, gpu)
mr = prior*np.mean(yh[y_t == +1] <= 0) + (1-prior)*np.mean(yh[y_t == -1] >= 0)
print("mr: {}".format(mr))
Example #13
| Source File: train.py From portrait_matting with GNU General Public License v3.0 | 4 votes |
|
def register_extensions(trainer, model, test_iter, args):
if args.mode.startswith('seg'):
# Max accuracy
best_trigger = training.triggers.BestValueTrigger(
'validation/main/accuracy', lambda a, b: a < b, (1, 'epoch'))
elif args.mode.startswith('mat'):
# Min loss
best_trigger = training.triggers.BestValueTrigger(
'validation/main/loss', lambda a, b: a > b, (1, 'epoch'))
else:
logger.error('Invalid training mode')
# Segmentation extensions
trainer.extend(
custom_extensions.PortraitVisEvaluator(
test_iter, model, device=args.gpus[0],
converter=select_converter(args.mode),
filename='vis_epoch={epoch}_idx={index}.jpg',
mode=args.mode
), trigger=(1, 'epoch'))
# Basic extensions
trainer.extend(extensions.dump_graph('main/loss'))
trainer.extend(extensions.LogReport(trigger=(200, 'iteration')))
trainer.extend(extensions.ProgressBar(update_interval=20))
trainer.extend(extensions.PrintReport(
['epoch', 'main/loss', 'validation/main/loss', 'main/accuracy',
'validation/main/accuracy', 'lr', 'elapsed_time']))
trainer.extend(extensions.observe_lr(), trigger=(200, 'iteration'))
# Snapshots
trainer.extend(extensions.snapshot(
filename='snapshot_epoch_{.updater.epoch}'
), trigger=(5, 'epoch'))
trainer.extend(extensions.snapshot_object(
model, filename='model_best'
), trigger=best_trigger)
# ChainerUI extensions
trainer.extend(chainerui.extensions.CommandsExtension())
chainerui.utils.save_args(args, args.out)
# Plotting extensions
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'))
Example #14
| Source File: trainer.py From Comicolorization with MIT License | 4 votes |
|
def create_trainer(
config,
project_path,
updater,
model,
eval_func,
iterator_test,
iterator_train_varidation,
loss_names,
converter=chainer.dataset.convert.concat_examples,
):
# type: (TrainConfig, str, any, typing.Dict, any, any, any, any, any) -> any
def _make_evaluator(iterator):
return utility.chainer_utility.NoVariableEvaluator(
iterator,
target=model,
converter=converter,
eval_func=eval_func,
device=config.gpu,
)
trainer = chainer.training.Trainer(updater, out=project_path)
log_trigger = (config.log_iteration, 'iteration')
save_trigger = (config.save_iteration, 'iteration')
eval_test_name = 'eval/test'
eval_train_name = 'eval/train'
snapshot = extensions.snapshot_object(model['main'], '{.updater.iteration}.model')
trainer.extend(snapshot, trigger=save_trigger)
trainer.extend(extensions.dump_graph('main/' + loss_names[0], out_name='main.dot'))
trainer.extend(_make_evaluator(iterator_test), name=eval_test_name, trigger=log_trigger)
trainer.extend(_make_evaluator(iterator_train_varidation), name=eval_train_name, trigger=log_trigger)
report_target = []
for evaluator_name in ['', eval_test_name + '/', eval_train_name + '/']:
for model_name in ['main/']:
for loss_name in loss_names:
report_target.append(evaluator_name + model_name + loss_name)
trainer.extend(extensions.LogReport(trigger=log_trigger, log_name="log.txt"))
trainer.extend(extensions.PrintReport(report_target))
return trainer
Example #15
| Source File: train.py From Video-frame-prediction-by-multi-scale-GAN with MIT License | 4 votes |
|
def main(resume, gpu, load_path, data_path):
dataset = Dataset(data_path)
GenNetwork = MultiScaleGenerator(c.SCALE_FMS_G, c.SCALE_KERNEL_SIZES_G)
DisNetwork = MultiScaleDiscriminator(c.SCALE_CONV_FMS_D, c.SCALE_KERNEL_SIZES_D, c.SCALE_FC_LAYER_SIZES_D)
optimizers = {}
optimizers["GeneratorNetwork"] = chainer.optimizers.SGD(c.LRATE_G)
optimizers["DiscriminatorNetwork"] = chainer.optimizers.SGD(c.LRATE_D)
iterator = chainer.iterators.SerialIterator(dataset, 1)
params = {'LAM_ADV': 0.05, 'LAM_LP': 1, 'LAM_GDL': .1}
updater = Updater(iterators=iterator, optimizers=optimizers,
GeneratorNetwork=GenNetwork,
DiscriminatorNetwork=DisNetwork,
params=params,
device=gpu
)
if gpu>=0:
updater.GenNetwork.to_gpu()
updater.DisNetwork.to_gpu()
trainer = chainer.training.Trainer(updater, (500000, 'iteration'), out='result')
trainer.extend(extensions.snapshot(filename='snapshot'), trigger=(1, 'iteration'))
trainer.extend(extensions.snapshot_object(trainer.updater.GenNetwork, "GEN"))
trainer.extend(saveGen)
log_keys = ['epoch', 'iteration', 'GeneratorNetwork/L2Loss', 'GeneratorNetwork/GDL',
'DiscriminatorNetwork/DisLoss', 'GeneratorNetwork/CompositeGenLoss']
print_keys = ['GeneratorNetwork/CompositeGenLoss','DiscriminatorNetwork/DisLoss']
trainer.extend(extensions.LogReport(keys=log_keys, trigger=(10, 'iteration')))
trainer.extend(extensions.PrintReport(print_keys), trigger=(10, 'iteration'))
trainer.extend(extensions.PlotReport(['DiscriminatorNetwork/DisLoss'], 'iteration', (10, 'iteration'), file_name="DisLoss.png"))
trainer.extend(extensions.PlotReport(['GeneratorNetwork/CompositeGenLoss'], 'iteration', (10, 'iteration'), file_name="GenLoss.png"))
trainer.extend(extensions.PlotReport(['GeneratorNetwork/AdvLoss'], 'iteration', (10, 'iteration'), file_name="AdvGenLoss.png"))
trainer.extend(extensions.PlotReport(['GeneratorNetwork/AdvLoss','DiscriminatorNetwork/DisLoss'], 'iteration', (10, 'iteration'), file_name="AdversarialLosses.png"))
trainer.extend(extensions.PlotReport(['GeneratorNetwork/L2Loss'], 'iteration', (10, 'iteration'),file_name="L2Loss.png"))
trainer.extend(extensions.PlotReport(['GeneratorNetwork/GDL'], 'iteration', (10, 'iteration'),file_name="GDL.png"))
trainer.extend(extensions.ProgressBar(update_interval=10))
if resume:
# Resume from a snapshot
chainer.serializers.load_npz(load_path, trainer)
print(trainer.updater.__dict__)
trainer.run()
