def set_trainer(self, out_dir, gpu, n_epoch, g_clip, opt_name, lr=None):
if opt_name == "Adam":
opt = getattr(optimizers, opt_name)()
else:
opt = getattr(optimizers, opt_name)(lr)
opt.setup(self.model)
opt.add_hook(optimizer.GradientClipping(g_clip))
updater = training.StandardUpdater(self.train_iter, opt, device=gpu)
self.trainer = training.Trainer(updater, (n_epoch, 'epoch'), out=out_dir)
self.trainer.extend(extensions.Evaluator(self.test_iter, self.model, device=gpu))
self.trainer.extend(extensions.dump_graph('main/loss'))
self.trainer.extend(extensions.snapshot(), trigger=(n_epoch, 'epoch'))
self.trainer.extend(extensions.LogReport())
self.trainer.extend(extensions.PlotReport(['main/loss', 'validation/main/loss'],
'epoch', file_name='loss.png'))
self.trainer.extend(extensions.PlotReport(['main/accuracy', 'validation/main/accuracy'],
'epoch', file_name='accuracy.png'))
self.trainer.extend(extensions.PrintReport(['epoch', 'main/loss', 'validation/main/loss',
'main/accuracy', 'validation/main/accuracy',
'elapsed_time']))
self.trainer.extend(extensions.ProgressBar())
python类snapshot()的实例源码
def __init__(self, **kwargs):
required_keys = []
optional_keys = [
'dump_graph',
'Evaluator',
'ExponentialShift',
'LinearShift',
'LogReport',
'observe_lr',
'observe_value',
'snapshot',
'PlotReport',
'PrintReport',
]
super().__init__(
required_keys, optional_keys, kwargs, self.__class__.__name__)
def __init__(self, **kwargs):
required_keys = []
optional_keys = [
'dump_graph',
'Evaluator',
'ExponentialShift',
'LinearShift',
'LogReport',
'observe_lr',
'observe_value',
'snapshot',
'PlotReport',
'PrintReport',
]
super().__init__(
required_keys, optional_keys, kwargs, self.__class__.__name__)
def train(args):
model = EmbeddingTagger(args.model, 50, 20, 30)
model.setup_training(args.embed)
if args.initmodel:
print('Load model from', args.initmodel)
chainer.serializers.load_npz(args.initmodel, model)
train = CCGBankDataset(args.model, args.train)
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
val = CCGBankDataset(args.model, args.val)
val_iter = chainer.iterators.SerialIterator(
val, args.batchsize, repeat=False, shuffle=False)
optimizer = chainer.optimizers.SGD(lr=0.01)
optimizer.setup(model)
updater = training.StandardUpdater(train_iter, optimizer)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), args.model)
val_interval = 5000, 'iteration'
log_interval = 200, 'iteration'
val_model = model.copy()
trainer.extend(extensions.Evaluator(val_iter, val_model), trigger=val_interval)
trainer.extend(extensions.dump_graph('main/loss'))
trainer.extend(extensions.snapshot(), trigger=val_interval)
trainer.extend(extensions.snapshot_object(
model, 'model_iter_{.updater.iteration}'), trigger=val_interval)
trainer.extend(extensions.LogReport(trigger=log_interval))
trainer.extend(extensions.PrintReport([
'epoch', 'iteration', 'main/loss', 'validation/main/loss',
'main/accuracy', 'validation/main/accuracy',
]), trigger=log_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.run()
def main():
unit = 1000
batchsize = 100
epoch = 20
model = L.Classifier(MLP(unit, 10))
optimizer = chainer.optimizers.Adam()
optimizer.setup(model)
train, test = chainer.datasets.get_mnist()
train_iter = chainer.iterators.SerialIterator(train, batchsize)
test_iter = chainer.iterators.SerialIterator(test, batchsize, repeat=False, shuffle=False)
updater = training.StandardUpdater(train_iter, optimizer)
trainer = training.Trainer(updater, (epoch, 'epoch'), out='result')
trainer.extend(extensions.Evaluator(test_iter, model))
trainer.extend(extensions.dump_graph('main/loss'))
trainer.extend(extensions.snapshot(), trigger=(epoch, 'epoch'))
trainer.extend(extensions.LogReport())
trainer.extend(extensions.PrintReport(
['epoch', 'main/loss', 'validation/main/loss',
'main/accuracy', 'validation/main/accuracy', 'elapsed_time']))
trainer.extend(extensions.ProgressBar())
trainer.run()
def fit(model, train, valid, device=-1, batchsize=4096, n_epoch=500,
resume=None, alpha=1e-3):
if device >= 0:
chainer.cuda.get_device(device).use()
model.to_gpu(device)
optimizer = chainer.optimizers.Adam(alpha)
optimizer.setup(model)
# Setup iterators
train_iter = chainer.iterators.SerialIterator(train, batchsize)
valid_iter = chainer.iterators.SerialIterator(valid, batchsize,
repeat=False, shuffle=False)
updater = training.StandardUpdater(train_iter, optimizer, device=device)
trainer = training.Trainer(updater, (n_epoch, 'epoch'),
out='out_' + str(device))
# Setup logging, printing & saving
keys = ['loss', 'rmse', 'bias', 'kld0', 'kld1']
keys += ['kldg', 'kldi', 'hypg', 'hypi']
keys += ['hypglv', 'hypilv']
reports = ['epoch']
reports += ['main/' + key for key in keys]
reports += ['validation/main/rmse']
trainer.extend(TestModeEvaluator(valid_iter, model, device=device))
trainer.extend(extensions.Evaluator(valid_iter, model, device=device))
trainer.extend(extensions.dump_graph('main/loss'))
trainer.extend(extensions.snapshot(), trigger=(10, 'epoch'))
trainer.extend(extensions.LogReport(trigger=(1, 'epoch')))
trainer.extend(extensions.PrintReport(reports))
trainer.extend(extensions.ProgressBar(update_interval=10))
# If previous model detected, resume
if resume:
print("Loading from {}".format(resume))
chainer.serializers.load_npz(resume, trainer)
# Run the model
trainer.run()
def pretrain_source_cnn(data, args, epochs=1000):
print(":: pretraining source encoder")
source_cnn = Loss(num_classes=10)
if args.device >= 0:
source_cnn.to_gpu()
optimizer = chainer.optimizers.Adam()
optimizer.setup(source_cnn)
train_iterator, test_iterator = data2iterator(data, args.batchsize, multiprocess=False)
# train_iterator = chainer.iterators.MultiprocessIterator(data, args.batchsize, n_processes=4)
updater = chainer.training.StandardUpdater(iterator=train_iterator, optimizer=optimizer, device=args.device)
trainer = chainer.training.Trainer(updater, (epochs, 'epoch') ,out=args.output)
# learning rate decay
# trainer.extend(extensions.ExponentialShift("alpha", rate=0.9, init=args.learning_rate, target=args.learning_rate*10E-5))
trainer.extend(extensions.Evaluator(test_iterator, source_cnn, device=args.device))
# trainer.extend(extensions.snapshot(filename='snapshot_epoch_{.updater.epoch}'), trigger=(10, "epoch"))
trainer.extend(extensions.snapshot_object(optimizer.target, "source_model_epoch_{.updater.epoch}"), trigger=(epochs, "epoch"))
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.extend(extensions.LogReport(trigger=(1, "epoch")))
trainer.extend(extensions.PrintReport(
['epoch', 'main/loss', 'validation/main/loss',
'main/accuracy', 'validation/main/accuracy', 'elapsed_time']))
trainer.run()
return source_cnn
def train_target_cnn(source, target, source_cnn, target_cnn, args, epochs=10000):
print(":: training encoder with target domain")
discriminator = Discriminator()
if args.device >= 0:
source_cnn.to_gpu()
target_cnn.to_gpu()
discriminator.to_gpu()
# target_optimizer = chainer.optimizers.Adam(alpha=1.0E-5, beta1=0.5)
target_optimizer = chainer.optimizers.RMSprop(lr=args.lr)
# target_optimizer = chainer.optimizers.MomentumSGD(lr=1.0E-4, momentum=0.99)
target_optimizer.setup(target_cnn.encoder)
target_optimizer.add_hook(chainer.optimizer.WeightDecay(args.weight_decay))
# discriminator_optimizer = chainer.optimizers.Adam(alpha=1.0E-5, beta1=0.5)
discriminator_optimizer = chainer.optimizers.RMSprop(lr=args.lr)
# discriminator_optimizer = chainer.optimizers.MomentumSGD(lr=1.0E-4, momentum=0.99)
discriminator_optimizer.setup(discriminator)
discriminator_optimizer.add_hook(chainer.optimizer.WeightDecay(args.weight_decay))
source_train_iterator, source_test_iterator = data2iterator(source, args.batchsize, multiprocess=False)
target_train_iterator, target_test_iterator = data2iterator(target, args.batchsize, multiprocess=False)
updater = ADDAUpdater(source_train_iterator, target_train_iterator, source_cnn, target_optimizer, discriminator_optimizer, args)
trainer = chainer.training.Trainer(updater, (epochs, 'epoch'), out=args.output)
trainer.extend(extensions.Evaluator(target_test_iterator, target_cnn, device=args.device))
# trainer.extend(extensions.snapshot(filename='snapshot_epoch_{.updater.epoch}'), trigger=(10, "epoch"))
trainer.extend(extensions.snapshot_object(target_cnn, "target_model_epoch_{.updater.epoch}"), trigger=(epochs, "epoch"))
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.extend(extensions.LogReport(trigger=(1, "epoch")))
trainer.extend(extensions.PrintReport(
["epoch", "loss/discrim", "loss/encoder",
"validation/main/loss", "validation/main/accuracy", "elapsed_time"]))
trainer.run()
02-train.py 文件源码
项目：Semantic-Segmentation-using-Adversarial-Networks
作者: oyam
项目源码
文件源码
阅读 24
收藏 0
点赞 0
评论 0
def parse_args(generators, discriminators, updaters):
parser = argparse.ArgumentParser(description='Semantic Segmentation using Adversarial Networks')
parser.add_argument('--generator', choices=generators.keys(), default='fcn32s',
help='Generator(segmentor) architecture')
parser.add_argument('--discriminator', choices=discriminators.keys(), default='largefov',
help='Discriminator architecture')
parser.add_argument('--updater', choices=updaters.keys(), default='gan',
help='Updater')
parser.add_argument('--initgen_path', default='pretrained_model/vgg16.npz',
help='Pretrained model of generator')
parser.add_argument('--initdis_path', default=None,
help='Pretrained model of discriminator')
parser.add_argument('--batchsize', '-b', type=int, default=1,
help='Number of images in each mini-batch')
parser.add_argument('--iteration', '-i', type=int, default=100000,
help='Number of sweeps over the dataset to train')
parser.add_argument('--gpu', '-g', type=int, default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--out', '-o', default='snapshot',
help='Directory to output the result')
parser.add_argument('--resume', '-r', default='',
help='Resume the training from snapshot')
parser.add_argument('--evaluate_interval', type=int, default=1000,
help='Interval of evaluation')
parser.add_argument('--snapshot_interval', type=int, default=10000,
help='Interval of snapshot')
parser.add_argument('--display_interval', type=int, default=10,
help='Interval of displaying log to console')
return parser.parse_args()
def fit(self, X, y=None, **kwargs):
"""If hyper parameters are set to None, then instance's variable is used,
this functionality is used Grid search with `set_params` method.
Also if instance's variable is not set, _default_hyperparam is used.
Usage: model.fit(train_dataset) or model.fit(X, y)
Args:
train: training dataset, assumes chainer's dataset class
test: test dataset for evaluation, assumes chainer's dataset class
batchsize: batchsize for both training and evaluation
iterator_class: iterator class used for this training,
currently assumes SerialIterator or MultiProcessIterator
optimizer: optimizer instance to update parameter
epoch: training epoch
out: directory path to save the result
snapshot_frequency (int): snapshot frequency in epoch.
Negative value indicates not to take snapshot.
dump_graph: Save computational graph info or not, default is False.
log_report: Enable LogReport or not
plot_report: Enable PlotReport or not
print_report: Enable PrintReport or not
progress_report: Enable ProgressReport or not
resume: specify trainer saved path to resume training.
"""
kwargs = self.filter_sk_params(self.fit_core, kwargs)
return self.fit_core(X, y, **kwargs)
def train(args):
model = JaCCGEmbeddingTagger(args.model,
args.word_emb_size, args.char_emb_size)
if args.initmodel:
print('Load model from', args.initmodel)
chainer.serializers.load_npz(args.initmodel, model)
if args.pretrained:
print('Load pretrained word embeddings from', args.pretrained)
model.load_pretrained_embeddings(args.pretrained)
train = JaCCGTaggerDataset(args.model, args.train)
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
val = JaCCGTaggerDataset(args.model, args.val)
val_iter = chainer.iterators.SerialIterator(
val, args.batchsize, repeat=False, shuffle=False)
optimizer = chainer.optimizers.AdaGrad()
optimizer.setup(model)
# optimizer.add_hook(WeightDecay(1e-8))
my_converter = lambda x, dev: convert.concat_examples(x, dev, (None,-1,None,None))
updater = training.StandardUpdater(train_iter, optimizer, converter=my_converter)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), args.model)
val_interval = 1000, 'iteration'
log_interval = 200, 'iteration'
eval_model = model.copy()
eval_model.train = False
trainer.extend(extensions.Evaluator(
val_iter, eval_model, my_converter), trigger=val_interval)
trainer.extend(extensions.dump_graph('main/loss'))
trainer.extend(extensions.snapshot(), trigger=val_interval)
trainer.extend(extensions.snapshot_object(
model, 'model_iter_{.updater.iteration}'), trigger=val_interval)
trainer.extend(extensions.LogReport(trigger=log_interval))
trainer.extend(extensions.PrintReport([
'epoch', 'iteration', 'main/loss', 'validation/main/loss',
'main/accuracy', 'validation/main/accuracy',
]), trigger=log_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.run()
def start(self):
""" Train pose net. """
# set random seed.
if self.seed is not None:
random.seed(self.seed)
np.random.seed(self.seed)
if self.gpu >= 0:
chainer.cuda.cupy.random.seed(self.seed)
# initialize model to train.
model = AlexNet(self.Nj, self.use_visibility)
if self.resume_model:
serializers.load_npz(self.resume_model, model)
# prepare gpu.
if self.gpu >= 0:
chainer.cuda.get_device(self.gpu).use()
model.to_gpu()
# load the datasets.
train = PoseDataset(self.train, data_augmentation=self.data_augmentation)
val = PoseDataset(self.val, data_augmentation=False)
# training/validation iterators.
train_iter = chainer.iterators.MultiprocessIterator(
train, self.batchsize)
val_iter = chainer.iterators.MultiprocessIterator(
val, self.batchsize, repeat=False, shuffle=False)
# set up an optimizer.
optimizer = self._get_optimizer()
optimizer.setup(model)
if self.resume_opt:
chainer.serializers.load_npz(self.resume_opt, optimizer)
# set up a trainer.
updater = training.StandardUpdater(train_iter, optimizer, device=self.gpu)
trainer = training.Trainer(
updater, (self.epoch, 'epoch'), os.path.join(self.out, 'chainer'))
# standard trainer settings
trainer.extend(extensions.dump_graph('main/loss'))
val_interval = (10, 'epoch')
trainer.extend(TestModeEvaluator(val_iter, model, device=self.gpu), trigger=val_interval)
# save parameters and optimization state per validation step
resume_interval = (self.epoch/10, 'epoch')
trainer.extend(extensions.snapshot_object(
model, "epoch-{.updater.epoch}.model"), trigger=resume_interval)
trainer.extend(extensions.snapshot_object(
optimizer, "epoch-{.updater.epoch}.state"), trigger=resume_interval)
trainer.extend(extensions.snapshot(
filename="epoch-{.updater.epoch}.iter"), trigger=resume_interval)
# show log
log_interval = (10, "iteration")
trainer.extend(extensions.LogReport(trigger=log_interval))
trainer.extend(extensions.observe_lr(), trigger=log_interval)
trainer.extend(extensions.PrintReport(
['epoch', 'main/loss', 'validation/main/loss', 'lr']), trigger=log_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
# start training
if self.resume:
chainer.serializers.load_npz(self.resume, trainer)
trainer.run()
def __init__(self, folder, chain, train, test, batchsize=500, resume=True, gpu=0, nepoch=1, reports=[]):
self.reports = reports
self.nepoch = nepoch
self.folder = folder
self.chain = chain
self.gpu = gpu
if self.gpu >= 0:
chainer.cuda.get_device(gpu).use()
chain.to_gpu(gpu)
self.eval_chain = eval_chain = chain.copy()
self.chain.test = False
self.eval_chain.test = True
self.testset = test
if not os.path.exists(folder):
os.makedirs(folder)
train_iter = chainer.iterators.SerialIterator(train, batchsize, shuffle=True)
test_iter = chainer.iterators.SerialIterator(test, batchsize,
repeat=False, shuffle=False)
updater = training.StandardUpdater(train_iter, chain.optimizer, device=gpu)
trainer = training.Trainer(updater, (nepoch, 'epoch'), out=folder)
# trainer.extend(TrainingModeSwitch(chain))
trainer.extend(extensions.dump_graph('main/loss'))
trainer.extend(extensions.Evaluator(test_iter, eval_chain, device=gpu), trigger=(1,'epoch'))
trainer.extend(extensions.snapshot_object(
chain, 'chain_snapshot_epoch_{.updater.epoch:06}'), trigger=(1,'epoch'))
trainer.extend(extensions.snapshot(
filename='snapshot_epoch_{.updater.epoch:06}'), trigger=(1,'epoch'))
trainer.extend(extensions.LogReport(trigger=(1,'epoch')), trigger=(1,'iteration'))
trainer.extend(extensions.PrintReport(
['epoch']+reports), trigger=IntervalTrigger(1,'epoch'))
self.trainer = trainer
if resume:
#if resumeFrom is not None:
# trainerFile = os.path.join(resumeFrom[0],'snapshot_epoch_{:06}'.format(resumeFrom[1]))
# S.load_npz(trainerFile, trainer)
i = 1
trainerFile = os.path.join(folder,'snapshot_epoch_{:06}'.format(i))
while i <= nepoch and os.path.isfile(trainerFile):
i = i + 1
trainerFile = os.path.join(folder,'snapshot_epoch_{:06}'.format(i))
i = i - 1
trainerFile = os.path.join(folder,'snapshot_epoch_{:06}'.format(i))
if i >= 0 and os.path.isfile(trainerFile):
S.load_npz(trainerFile, trainer)
