我们从Python开源项目中，提取了以下25个代码示例，用于说明如何使用chainer.training.Trainer()。
def train(network, loss, X_tr, Y_tr, X_te, Y_te, n_epochs=30, gamma=1): model= Objective(network, loss=loss, gamma=gamma) #optimizer = optimizers.SGD() optimizer = optimizers.Adam() optimizer.setup(model) train = tuple_dataset.TupleDataset(X_tr, Y_tr) test = tuple_dataset.TupleDataset(X_te, Y_te) train_iter = iterators.SerialIterator(train, batch_size=1, shuffle=True) test_iter = iterators.SerialIterator(test, batch_size=1, repeat=False, shuffle=False) updater = training.StandardUpdater(train_iter, optimizer) trainer = training.Trainer(updater, (n_epochs, 'epoch')) trainer.run()
def main(): model = L.Classifier(CNN()) optimizer = chainer.optimizers.Adam() optimizer.setup(model) train, test = chainer.datasets.get_mnist(ndim=3) train_iter = chainer.iterators.SerialIterator(train, batch_size=100) test_iter = chainer.iterators.SerialIterator(test, batch_size=100, repeat=False, shuffle=False) updater = training.StandardUpdater(train_iter, optimizer) trainer = training.Trainer(updater, (5, 'epoch'), out='result') trainer.extend(extensions.Evaluator(test_iter, model)) trainer.extend(extensions.LogReport()) trainer.extend(extensions.PrintReport( ['epoch', 'main/loss', 'validation/main/loss', 'main/accuracy','validation/main/accuracy'])) trainer.extend(extensions.ProgressBar()) trainer.run()
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())
def test_linear_network(): # To ensure repeatability of experiments np.random.seed(1042) # Load data set dataset = get_dataset(True) iterator = LtrIterator(dataset, repeat=True, shuffle=True) eval_iterator = LtrIterator(dataset, repeat=False, shuffle=False) # Create neural network with chainer and apply our loss function predictor = links.Linear(None, 1) loss = Ranker(predictor, listnet) # Build optimizer, updater and trainer optimizer = optimizers.Adam(alpha=0.2) optimizer.setup(loss) updater = training.StandardUpdater(iterator, optimizer) trainer = training.Trainer(updater, (10, 'epoch')) # Evaluate loss before training before_loss = eval(loss, eval_iterator) # Train neural network trainer.run() # Evaluate loss after training after_loss = eval(loss, eval_iterator) # Assert precomputed values assert_almost_equal(before_loss, 0.26958397) assert_almost_equal(after_loss, 0.2326711)
def main(gpu_id=-1, bs=32, epoch=20, out='./result', resume=''): net = ShallowConv() model = L.Classifier(net) if gpu_id >= 0: chainer.cuda.get_device_from_id(gpu_id) model.to_gpu() optimizer = chainer.optimizers.Adam() optimizer.setup(model) train, test = chainer.datasets.get_mnist(ndim=3) train_iter = chainer.iterators.SerialIterator(train, bs) test_iter = chainer.iterators.SerialIterator( test, bs, repeat=False, shuffle=False) updater = training.StandardUpdater(train_iter, optimizer, device=gpu_id) trainer = training.Trainer(updater, (epoch, 'epoch'), out=out) trainer.extend(extensions.ParameterStatistics(model.predictor)) trainer.extend(extensions.Evaluator(test_iter, model, device=gpu_id)) trainer.extend(extensions.LogReport(log_name='parameter_statistics')) trainer.extend(extensions.PrintReport( ['epoch', 'main/loss', 'validation/main/loss', 'main/accuracy', 'validation/main/accuracy', 'elapsed_time'])) trainer.extend(extensions.ProgressBar()) if resume: chainer.serializers.load_npz(resume, trainer) trainer.run()
def main(gpu_id=-1, bs=32, epoch=20, out='./not_layer_result', resume=''): net = ShallowConv() model = L.Classifier(net) if gpu_id >= 0: chainer.cuda.get_device_from_id(gpu_id) model.to_gpu() optimizer = chainer.optimizers.Adam() optimizer.setup(model) train, test = chainer.datasets.get_mnist(ndim=3) train_iter = chainer.iterators.SerialIterator(train, bs) test_iter = chainer.iterators.SerialIterator(test, bs, repeat=False, shuffle=False) updater = training.StandardUpdater(train_iter, optimizer, device=gpu_id) trainer = training.Trainer(updater, (epoch, 'epoch'), out=out) trainer.extend(extensions.ParameterStatistics(model.predictor)) trainer.extend(extensions.Evaluator(test_iter, model, device=gpu_id)) 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()) if resume: chainer.serializers.load_npz(resume, trainer) trainer.run()
def get_trainer(updater, evaluator, epochs): trainer = training.Trainer(updater, (epochs, 'epoch'), out='result') trainer.extend(evaluator) # TODO: reduce LR -- how to update every X epochs? # trainer.extend(extensions.ExponentialShift('lr', 0.1, target=lr*0.0001)) trainer.extend(extensions.LogReport()) trainer.extend(extensions.ProgressBar( (epochs, 'epoch'), update_interval=10)) trainer.extend(extensions.PrintReport( ['epoch', 'main/loss', 'validation/main/loss'])) return trainer
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 train(args): nz = args.nz batch_size = args.batch_size epochs = args.epochs gpu = args.gpu # CIFAR-10 images in range [-1, 1] (tanh generator outputs) train, _ = datasets.get_cifar10(withlabel=False, ndim=3, scale=2) train -= 1.0 train_iter = iterators.SerialIterator(train, batch_size) z_iter = RandomNoiseIterator(GaussianNoiseGenerator(0, 1, args.nz), batch_size) optimizer_generator = optimizers.RMSprop(lr=0.00005) optimizer_critic = optimizers.RMSprop(lr=0.00005) optimizer_generator.setup(Generator()) optimizer_critic.setup(Critic()) updater = WassersteinGANUpdater( iterator=train_iter, noise_iterator=z_iter, optimizer_generator=optimizer_generator, optimizer_critic=optimizer_critic, device=gpu) trainer = training.Trainer(updater, stop_trigger=(epochs, 'epoch')) trainer.extend(extensions.ProgressBar()) trainer.extend(extensions.LogReport(trigger=(1, 'iteration'))) trainer.extend(GeneratorSample(), trigger=(1, 'epoch')) trainer.extend(extensions.PrintReport(['epoch', 'iteration', 'critic/loss', 'critic/loss/real', 'critic/loss/fake', 'generator/loss'])) 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 train(args): model = LSTMParser(args.model, args.word_emb_size, args.afix_emb_size, args.nlayers, args.hidden_dim, args.elu_dim, args.dep_dim, args.dropout_ratio) with open(args.model + "/params", "w") as f: log(args, f) 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) if args.gpu >= 0: chainer.cuda.get_device(args.gpu).use() model.to_gpu() train = LSTMParserDataset(args.model, args.train) train_iter = chainer.iterators.SerialIterator(train, args.batchsize) val = LSTMParserDataset(args.model, args.val) val_iter = chainer.iterators.SerialIterator( val, args.batchsize, repeat=False, shuffle=False) optimizer = chainer.optimizers.Adam(beta2=0.9) # optimizer = chainer.optimizers.MomentumSGD(momentum=0.7) optimizer.setup(model) optimizer.add_hook(WeightDecay(1e-6)) # optimizer.add_hook(GradientClipping(5.)) updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu, converter=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, converter, device=args.gpu), 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/tagging_accuracy', 'main/tagging_loss', 'main/parsing_accuracy', 'main/parsing_loss', 'validation/main/tagging_accuracy', 'validation/main/parsing_accuracy' ]), trigger=log_interval) trainer.extend(extensions.ProgressBar(update_interval=10)) trainer.run()
def train(args): model = LSTMTagger(args.model, args.word_emb_size, args.afix_emb_size, args.nlayers, args.hidden_dim, args.relu_dim, args.dropout_ratio) with open(args.model + "/params", "w") as f: log(args, f) 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) if args.gpu >= 0: chainer.cuda.get_device(args.gpu).use() model.to_gpu() train = LSTMTaggerDataset(args.model, args.train) train_iter = chainer.iterators.SerialIterator(train, args.batchsize) val = LSTMTaggerDataset(args.model, args.val) val_iter = chainer.iterators.SerialIterator( val, args.batchsize, repeat=False, shuffle=False) optimizer = chainer.optimizers.MomentumSGD(momentum=0.7) optimizer.setup(model) optimizer.add_hook(WeightDecay(1e-6)) optimizer.add_hook(GradientClipping(5.)) updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu, converter=converter) trainer = training.Trainer(updater, (args.epoch, 'epoch'), args.model) val_interval = 2000, 'iteration' log_interval = 200, 'iteration' eval_model = model.copy() eval_model.train = False trainer.extend(extensions.Evaluator( val_iter, eval_model, converter, device=args.gpu), 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 train(args): model = BiaffineJaLSTMParser(args.model, args.word_emb_size, args.char_emb_size, args.nlayers, args.hidden_dim, args.dep_dim, args.dropout_ratio) with open(args.model + "/params", "w") as f: log(args, f) 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) if args.gpu >= 0: chainer.cuda.get_device(args.gpu).use() model.to_gpu() train = LSTMParserDataset(args.model, args.train) train_iter = chainer.iterators.SerialIterator(train, args.batchsize) val = LSTMParserDataset(args.model, args.val) val_iter = chainer.iterators.SerialIterator( val, args.batchsize, repeat=False, shuffle=False) optimizer = chainer.optimizers.Adam(beta2=0.9) # optimizer = chainer.optimizers.MomentumSGD(momentum=0.7) optimizer.setup(model) optimizer.add_hook(WeightDecay(2e-6)) # optimizer.add_hook(GradientClipping(5.)) updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu, converter=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.ExponentialShift( "eps", .75, 2e-3), trigger=(2500, 'iteration')) trainer.extend(extensions.Evaluator( val_iter, eval_model, converter, device=args.gpu), 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/tagging_accuracy', 'main/tagging_loss', 'main/parsing_accuracy', 'main/parsing_loss', 'validation/main/tagging_accuracy', 'validation/main/parsing_accuracy' ]), trigger=log_interval) trainer.extend(extensions.ProgressBar(update_interval=10)) trainer.run()
def train(args): model = JaLSTMParser(args.model, args.word_emb_size, args.char_emb_size, args.nlayers, args.hidden_dim, args.relu_dim, args.dep_dim, args.dropout_ratio) with open(args.model + "/params", "w") as f: log(args, f) 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 = LSTMParserDataset(args.model, args.train) train_iter = chainer.iterators.SerialIterator(train, args.batchsize) val = LSTMParserDataset(args.model, args.val) val_iter = chainer.iterators.SerialIterator( val, args.batchsize, repeat=False, shuffle=False) optimizer = chainer.optimizers.Adam(beta2=0.9) # optimizer = chainer.optimizers.MomentumSGD(momentum=0.7) optimizer.setup(model) optimizer.add_hook(WeightDecay(1e-6)) # optimizer.add_hook(GradientClipping(5.)) updater = training.StandardUpdater(train_iter, optimizer, converter=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, converter), 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/tagging_loss', 'main/tagging_accuracy', 'main/tagging_loss', 'main/parsing_accuracy', 'main/parsing_loss', 'validation/main/tagging_loss', 'validation/main/tagging_accuracy', 'validation/main/parsing_loss', 'validation/main/parsing_accuracy' ]), trigger=log_interval) trainer.extend(extensions.ProgressBar(update_interval=10)) trainer.run()
def train(args): model = LSTMTagger(args.model, args.word_emb_size, args.char_emb_size, args.nlayers, args.hidden_dim, args.relu_dim, args.dropout_ratio) with open(args.model + "/params", "w") as f: log(args, f) 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 = LSTMTaggerDataset(args.model, args.train) train_iter = chainer.iterators.SerialIterator(train, args.batchsize) val = LSTMTaggerDataset(args.model, args.val) val_iter = chainer.iterators.SerialIterator( val, args.batchsize, repeat=False, shuffle=False) optimizer = chainer.optimizers.MomentumSGD(momentum=0.7) optimizer.setup(model) optimizer.add_hook(WeightDecay(1e-6)) # optimizer.add_hook(GradientClipping(5.)) updater = training.StandardUpdater(train_iter, optimizer, converter=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, converter), 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 train(args): model = LSTMTagger(args.model, args.word_emb_size, args.afix_emb_size, args.nlayers, args.hidden_dim, args.relu_dim, args.dropout_ratio) with open(args.model + "/params", "w") as f: log(args, f) 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) if args.gpu >= 0: chainer.cuda.get_device(args.gpu).use() model.to_gpu() train = LSTMTaggerDataset(args.model, args.train) train_iter = chainer.iterators.SerialIterator(train, args.batchsize) val = LSTMTaggerDataset(args.model, args.val) val_iter = chainer.iterators.SerialIterator( val, args.batchsize, repeat=False, shuffle=False) optimizer = chainer.optimizers.MomentumSGD(momentum=0.7) optimizer.setup(model) optimizer.add_hook(WeightDecay(1e-6)) optimizer.add_hook(GradientClipping(5.)) updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu, converter=converter) trainer = training.Trainer(updater, (args.epoch, 'epoch'), args.model) val_interval = 2000, 'iteration' log_interval = 200, 'iteration' eval_model = model.copy() eval_model.train = False trainer.extend(extensions.Evaluator( val_iter, eval_model, converter, device=args.gpu), 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 train(args): model = LSTMParser(args.model, args.word_emb_size, args.afix_emb_size, args.nlayers, args.hidden_dim, args.elu_dim, args.dep_dim, args.dropout_ratio) with open(args.model + "/params", "w") as f: log(args, f) 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) if args.gpu >= 0: chainer.cuda.get_device(args.gpu).use() model.to_gpu() train = LSTMParserDataset(args.model, args.train) train_iter = chainer.iterators.SerialIterator(train, args.batchsize) val = LSTMParserDataset(args.model, args.val) val_iter = chainer.iterators.SerialIterator( val, args.batchsize, repeat=False, shuffle=False) optimizer = chainer.optimizers.Adam(beta2=0.9) # optimizer = chainer.optimizers.MomentumSGD(momentum=0.7) optimizer.setup(model) optimizer.add_hook(WeightDecay(1e-6)) # optimizer.add_hook(GradientClipping(5.)) updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu, converter=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, converter, device=args.gpu), 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/tagging_accuracy', 'main/tagging_loss', 'main/parsing_accuracy', 'main/parsing_loss', 'validation/main/tagging_accuracy', 'validation/main/parsing_accuracy' ]), trigger=log_interval) trainer.extend(extensions.ProgressBar(update_interval=10)) trainer.run()
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 train(args): model = PeepHoleLSTMTagger(args.model, args.word_emb_size, args.afix_emb_size, args.nlayers, args.hidden_dim, args.relu_dim, args.dropout_ratio) with open(args.model + "/params", "w") as f: log(args, f) 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) if args.gpu >= 0: chainer.cuda.get_device(args.gpu).use() model.to_gpu() converter = lambda x, device: \ concat_examples(x, device=device, padding=-1) train = LSTMTaggerDataset(args.model, args.train) train_iter = SerialIterator(train, args.batchsize) val = LSTMTaggerDataset(args.model, args.val) val_iter = chainer.iterators.SerialIterator( val, args.batchsize, repeat=False, shuffle=False) optimizer = chainer.optimizers.MomentumSGD(momentum=0.7) optimizer.setup(model) optimizer.add_hook(WeightDecay(1e-6)) optimizer.add_hook(GradientClipping(5.)) updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu, converter=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, converter, device=args.gpu), 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 train(args): time_start = timer() if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() cuda.check_cuda_available() if args.path_vocab == '': vocab = create_from_dir(args.path_corpus) else: vocab = Vocabulary() vocab.load(args.path_vocab) logger.info("loaded vocabulary") if args.context_representation != 'word': # for deps or ner context representation, we need a new context vocab for NS or HSM loss function. vocab_context = create_from_annotated_dir(args.path_corpus, representation=args.context_representation) else : vocab_context = vocab loss_func = get_loss_func(args, vocab_context) model = get_model(args, loss_func, vocab) if args.gpu >= 0: model.to_gpu() logger.debug("model sent to gpu") optimizer = chainer.optimizers.Adam() optimizer.setup(model) if os.path.isfile(args.path_corpus): train, val = get_data(args.path_corpus, vocab) if args.test: train = train[:100] val = val[:100] train_iter = WindowIterator(train, args.window, args.batchsize) val_iter = WindowIterator(val, args.window, args.batchsize, repeat=False) else: train_iter = DirWindowIterator(path=args.path_corpus, vocab=vocab, window_size=args.window, batch_size=args.batchsize) updater = training.StandardUpdater(train_iter, optimizer, converter=convert, device=args.gpu) trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.path_out) if os.path.isfile(args.path_corpus): trainer.extend(extensions.Evaluator(val_iter, model, converter=convert, device=args.gpu)) trainer.extend(extensions.LogReport()) if os.path.isfile(args.path_corpus): trainer.extend(extensions.PrintReport(['epoch', 'main/loss', 'validation/main/loss', 'elapsed_time'])) else: trainer.extend(extensions.PrintReport(['epoch', 'main/loss', 'elapsed_time'])) # trainer.extend(extensions.ProgressBar()) trainer.run() model = create_model(args, model, vocab) time_end = timer() model.metadata["execution_time"] = time_end - time_start return model
def main(options): #load the config params gpu = options['gpu'] data_path = options['path_dataset'] embeddings_path = options['path_vectors'] n_epoch = options['epochs'] batch_size = options['batchsize'] test = options['test'] embed_dim = options['embed_dim'] freeze = options['freeze_embeddings'] distance_embed_dim = options['distance_embed_dim'] #load the data data_processor = DataProcessor(data_path) data_processor.prepare_dataset() train_data = data_processor.train_data test_data = data_processor.test_data vocab = data_processor.vocab cnn = CNN(n_vocab=len(vocab), input_channel=1, output_channel=100, n_label=19, embed_dim=embed_dim, position_dims=distance_embed_dim, freeze=freeze) cnn.load_embeddings(embeddings_path, data_processor.vocab) model = L.Classifier(cnn) #use GPU if flag is set if gpu >= 0: model.to_gpu() #setup the optimizer optimizer = O.Adam() optimizer.setup(model) train_iter = chainer.iterators.SerialIterator(train_data, batch_size) test_iter = chainer.iterators.SerialIterator(test_data, batch_size,repeat=False, shuffle=False) updater = training.StandardUpdater(train_iter, optimizer, converter=convert.concat_examples, device=gpu) trainer = training.Trainer(updater, (n_epoch, 'epoch')) # Evaluation test_model = model.copy() test_model.predictor.train = False trainer.extend(extensions.Evaluator(test_iter, test_model, device=gpu, converter=convert.concat_examples)) trainer.extend(extensions.LogReport()) trainer.extend(extensions.PrintReport( ['epoch', 'main/loss', 'validation/main/loss', 'main/accuracy', 'validation/main/accuracy'])) trainer.extend(extensions.ProgressBar(update_interval=10)) trainer.run()
def main(options): #load the config params gpu = options['gpu'] data_path = options['path_dataset'] embeddings_path = options['path_vectors'] n_epoch = options['epochs'] batchsize = options['batchsize'] test = options['test'] embed_dim = options['embed_dim'] freeze = options['freeze_embeddings'] #load the data data_processor = DataProcessor(data_path, test) data_processor.prepare_dataset() train_data = data_processor.train_data dev_data = data_processor.dev_data test_data = data_processor.test_data vocab = data_processor.vocab cnn = CNN(n_vocab=len(vocab), input_channel=1, output_channel=10, n_label=2, embed_dim=embed_dim, freeze=freeze) cnn.load_embeddings(embeddings_path, data_processor.vocab) model = L.Classifier(cnn) if gpu >= 0: model.to_gpu() #setup the optimizer optimizer = O.Adam() optimizer.setup(model) train_iter = chainer.iterators.SerialIterator(train_data, batchsize) dev_iter = chainer.iterators.SerialIterator(dev_data, batchsize,repeat=False, shuffle=False) test_iter = chainer.iterators.SerialIterator(test_data, batchsize,repeat=False, shuffle=False) batch1 = train_iter.next() batch2 = dev_iter.next() updater = training.StandardUpdater(train_iter, optimizer, converter=util.concat_examples, device=gpu) trainer = training.Trainer(updater, (n_epoch, 'epoch')) # Evaluation eval_model = model.copy() eval_model.predictor.train = False trainer.extend(extensions.Evaluator(dev_iter, eval_model, device=gpu, converter=util.concat_examples)) test_model = model.copy() test_model.predictor.train = False trainer.extend(extensions.LogReport()) trainer.extend(extensions.PrintReport( ['epoch', 'main/loss', 'validation/main/loss', 'main/accuracy', 'validation/main/accuracy'])) trainer.extend(extensions.ProgressBar(update_interval=10)) 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)
