def train(opt, split): model = getattr(models, opt.netType)(opt.nClasses) model.to_gpu() optimizer = chainer.optimizers.NesterovAG(lr=opt.LR, momentum=opt.momentum) optimizer.setup(model) optimizer.add_hook(chainer.optimizer.WeightDecay(opt.weightDecay)) train_iter, val_iter = dataset.setup(opt, split) trainer = Trainer(model, optimizer, train_iter, val_iter, opt) if opt.testOnly: chainer.serializers.load_npz( os.path.join(opt.save, 'model_split{}.npz'.format(split)), trainer.model) val_top1 = trainer.val() print('| Val: top1 {:.2f}'.format(val_top1)) return for epoch in range(1, opt.nEpochs + 1): train_loss, train_top1 = trainer.train(epoch) val_top1 = trainer.val() sys.stderr.write('\r\033[K') sys.stdout.write( '| Epoch: {}/{} | Train: LR {} Loss {:.3f} top1 {:.2f} | Val: top1 {:.2f}\n' .format(epoch, opt.nEpochs, trainer.optimizer.lr, train_loss, train_top1, val_top1)) sys.stdout.flush() if opt.save != 'None': chainer.serializers.save_npz( os.path.join(opt.save, 'model_split{}.npz'.format(split)), model)
def train(opt, trial): # Get filename for saving model if opt.BC: if opt.plus: learning = 'BC+' else: learning = 'BC' else: learning = 'standard' # Get current time now = datetime.now() # current date and time string_date = now.strftime("%d%H%M") # Save filename filename = "{}_{}_trial{}_{}.th".format(learning, opt.dataset, trial, string_date) # Keep track of best validation error rate best_val_error = 100.0 model = getattr(models, opt.netType)(opt.nClasses) if opt.noGPU == False: model.cuda() # TODO: there is no direct method in PyTorch with NesterovAG optimizer = torch.optim.SGD(params=model.parameters(), lr=opt.LR, momentum=opt.momentum, weight_decay=opt.weightDecay, nesterov=True) train_iter, val_iter = dataset.setup(opt) trainer = Trainer(model, optimizer, train_iter, val_iter, opt) for epoch in range(1, opt.nEpochs + 1): train_loss, train_top1 = trainer.train(epoch) val_top1 = trainer.val() trainer.scheduler.step() sys.stderr.write('\r\033[K') sys.stdout.write( '| Epoch: {}/{} | Train: LR {} Loss {:.3f} top1 {:.2f} | Val: top1 {:.2f}\n' .format(epoch, opt.nEpochs, trainer.scheduler.get_last_lr()[0], train_loss, train_top1, val_top1)) sys.stdout.flush() if val_top1 < best_val_error: best_val_error = val_top1 if opt.save != 'None': print("New best validation error rate: {} (Saved checkpoint)". format(best_val_error)) torch.save(model.state_dict(), os.path.join(opt.save, filename)) return best_val_error
def main(): opt = opts.parse() model = net.ConvNet(opt.n_classes, opt.BC, opt.nobias, opt.dropout_ratio) if opt.gpu > -1: chainer.cuda.get_device_from_id(opt.gpu).use() model.to_gpu() optimizer = optimizers.NesterovAG(lr=opt.LR, momentum=opt.momentum) optimizer.setup(model) optimizer.add_hook(chainer.optimizer.WeightDecay(opt.weight_decay)) train_iter, val_iter = dataset.setup(opt) updater = training.StandardUpdater(train_iter, optimizer, device=opt.gpu) # Trainer trainer = training.Trainer(updater, (opt.n_epochs, 'epoch'), opt.save) trainer.extend(extensions.ExponentialShift('lr', 0.1, opt.LR), trigger=ManualScheduleTrigger(opt.schedule, 'epoch')) trainer.extend(extensions.Evaluator(val_iter, model, device=opt.gpu), trigger=(1, 'epoch')) trainer.extend(extensions.dump_graph('main/loss')) trainer.extend(extensions.snapshot(filename='min_loss'), trigger=MinValueTrigger( key='validation/main/loss', trigger=(5, 'epoch'))) trainer.extend(extensions.snapshot(filename='max_accuracy'), trigger=MaxValueTrigger( key='validation/main/accuracy', trigger=(5, 'epoch'))) trainer.extend(extensions.snapshot_object(model, 'min_loss_model'), trigger=MinValueTrigger(key='validation/main/loss', trigger=(5, 'epoch'))) trainer.extend(extensions.snapshot_object(model, 'max_accuracy_model'), trigger=MaxValueTrigger(key='validation/main/accuracy', trigger=(5, 'epoch'))) trainer.extend(extensions.observe_lr()) trainer.extend(extensions.LogReport()) 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.PlotReport( ['lr'], 'epoch', file_name='learning_rate.png')) trainer.extend(extensions.PrintReport(['elapsed_time', 'epoch', 'iteration', 'lr', 'main/loss', 'main/accuracy', 'validation/main/loss', 'validation/main/accuracy'])) trainer.extend(extensions.ProgressBar(update_interval=25)) if opt.resume and os.path.exists(opt.resume): chainer.serializers.load_npz(opt.resume, trainer) # Run the training try: trainer.run() except Exception as e: import shutil import traceback print('\nerror message') print(traceback.format_exc()) shutil.rmtree(opt.save)
def test_rep(): import models.representation as models params = Params() config_file = 'config/local.ini' # define dataset in the config params.parse_config(config_file) import dataset reader = dataset.setup(params) params = dataset.process_embedding(reader,params) qdnn = models.setup(params) model = qdnn.getModel() model.compile(loss = params.loss, optimizer = units.getOptimizer(name=params.optimizer,lr=params.lr), metrics=['accuracy']) model.summary() (train_x, train_y),(test_x, test_y),(val_x, val_y) = reader.get_processed_data() # print(train_x.shape,train_y.shape) history = model.fit(x=train_x, y = train_y, batch_size = params.batch_size, epochs= params.epochs,validation_data= (test_x, test_y)) evaluation = model.evaluate(x = val_x, y = val_y)
def train(opt, trial): model = getattr(models, opt.netType)(opt.nClasses) model.to_gpu() optimizer = chainer.optimizers.NesterovAG(lr=opt.LR, momentum=opt.momentum) optimizer.setup(model) optimizer.add_hook(chainer.optimizer.WeightDecay(opt.weightDecay)) train_iter, val_iter = dataset.setup(opt) trainer = Trainer(model, optimizer, train_iter, val_iter, opt) train_error = np.empty(opt.nEpochs) test_error = np.empty(opt.nEpochs) for epoch in range(1, opt.nEpochs + 1): train_loss, train_top1 = trainer.train(epoch) val_top1 = trainer.val() sys.stderr.write('\r\033[K') sys.stdout.write( '| Epoch: {}/{} | Train: LR {} Loss {:.3f} top1 {:.2f} | Val: top1 {:.2f}\n' .format(epoch, opt.nEpochs, trainer.optimizer.lr, train_loss, train_top1, val_top1)) sys.stdout.flush() train_error[epoch - 1] = train_top1 test_error[epoch - 1] = val_top1 if opt.save != 'None': chainer.serializers.save_npz( os.path.join(opt.save, 'model_trial{}.npz'.format(trial)), model) plt.figure() plt.plot(np.arange(opt.nEpochs), np.array(train_error)) plt.plot(np.arange(opt.nEpochs), np.array(test_error)) plt.ylim([0, 30]) plt.xlabel('Epoch') plt.ylabel('Test Error (%)') plt.legend((['Train error', 'Test error'])) axes = plt.gca() axes.yaxis.grid() plt.savefig('.' + '/results' + '/trial' + str(trial) + '.jpg', format='jpg') plt.close()
default='config/run.ini') args = parser.parse_args() params = Params() params.parse_config(args.config_file) params.config_file = args.config_file mode = 'run' if 'mode' in params.__dict__: mode = params.mode set_seed(params) params.device = torch.device( 'cuda') if torch.cuda.is_available() else torch.device('cpu') if mode == 'run': results = [] reader = setup(params) reader.read(params) print(params.output_dim_emo) params.reader = reader if params.train_type == "joint": emo, act = run(params) save_performance(params, emo, "joint_emotion") save_performance(params, act, "joint_act") else: performance_dict = run(params) save_performance(params, performance_dict, params.train_type) elif mode == 'run_grid_search': print('Grid Search Begins.') if not 'grid_parameters_file' in params.__dict__:
logger.info("\n".join( [params.to_string(), "score: " + str(df.max().to_dict())])) K.clear_session() if __name__ == "__main__": # import argparse parser = argparse.ArgumentParser( description='running the complex embedding network') parser.add_argument('-gpu_num', action='store', dest='gpu_num', help='please enter the gpu num.', default=gpu_count) parser.add_argument('-gpu', action='store', dest='gpu', help='please enter the gpu num.', default=0) args = parser.parse_args() params = Params() config_file = 'config/config_local.ini' # define dataset in the config params.parse_config(config_file) reader = dataset.setup(params) params.reader = reader run(params)
f = join(dirpath, f) if f not in file_list and f.endswith(".th"): file_list.append(f) if len(file_list) == 0: raise ValueError("Empty list of checkpoints") return file_list if __name__ == "__main__": opt = eval_parse() device = torch.device("cuda" if cuda.is_available() else "cpu") train_iter, val_iter = dataset.setup(opt) # Get list of model paths checkpoints = get_model_paths(opt.checkpoint) for path in checkpoints: model = ConvNet(opt.nClasses) model.load_state_dict(torch.load(path, map_location=device)) model = model.to(device) line = "Loading/evaluating model {}".format(path) sys.stderr.write('\r\033[K' + line) sys.stderr.flush()