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()
