def train_model(data, word_embeddings):
# 10-fold cross validation
n_fold = 10
fold_size = int(len(data[0]) / n_fold)
loss_list, acc_list = [], []
for i in range(1, n_fold + 1):
FLAGS.train_time = i
train_data, valid_data = utils.split_train_valid(data, i, fold_size)
graph = tf.Graph()
with tf.Session(graph=graph) as sess:
model = Classifier(FLAGS, sess)
model.build_model()
loss, acc = model.run(train_data, valid_data, word_embeddings)
loss_list.append(loss)
acc_list.append(acc)
avg_loss = np.mean(loss_list)
avg_acc = np.mean(acc_list)
print("10fold_loss&acc:", avg_loss, avg_acc)
print('10fold_std_loss&acc:', np.std(loss_list), np.std(acc_list))
logging.debug('10fold_loss: ' + str(avg_loss) + '\t10fold_acc :' +
str(avg_acc))
logging.debug('10fold_loss_std: ' + str(np.std(loss_list)) +
'\t10fold_acc_std :' + str(np.std(acc_list)))
def main():
# data loading
data = Data(params_logger=params_logger,
train_logger=train_logger,
embedding_path=Path.skpgrm_path,
data_limit=None,
w2v_limit=None)
# classifier configuration and building
classifier = Classifier(model_name='niko',
max_seqlen=data.max_seqlen,
vocab_size=data.vocab_size,
n_dummy=data.n_dummy,
pretrained_embedding=data.embedding_matrix,
params_logger=params_logger,
train_logger=train_logger)
classifier.build_model()
# training phase (model kept every 5 epochs)
print("train.shape: ", data.train_x.shape)
# if max_seqlen is too small, train_x has only 2dim shapes so it will raise error
inputs = [data.train_x[:, i, :] for i in range(data.train_x.shape[1])]
answers = data.y
save_weight_path = os.path.join(save_model_path,
"weights.{epoch:02d}-{val_loss:.2f}.hdf5")
output_dict = classifier.train(inputs,
answers,
save_output=True,
validation_split=data.validation_split,
save_path=save_weight_path)
data_dict = data.retrieve_data()
# test phase
# TODO: make code clean (wrap these process up as one method in Data class)
test_stories = [data.test_x[:, i, :] for i in range(data.test_x.shape[1])]
test_inputs_with_1 = test_stories + [data.test_e1]
test_inputs_with_2 = test_stories + [data.test_e2]
answer_with_1 = classifier.test(
test_inputs_with_1, batchsize=32) # bsize for test does not matter
answer_with_2 = classifier.test(test_inputs_with_2, batchsize=32)
# test accuracy
acc = classifier.calculate_accuracy(answer_with_1,
answer_with_2,
gt=data.test_answers)
train_logger.info("test acc: {}".format(acc / float(data.test_x.shape[0])))
# model and output saving
save_intermed_output_path = os.path.join(save_model_path,
"output_dict.pkl")
save_data_path = os.path.join(save_model_path, "data.pkl")
with open(save_intermed_output_path, 'wb') as w:
pickle.dump(output_dict, w, protocol=4)
train_logger.info(
"output_dict saved: {}".format(save_intermed_output_path))
with open(save_data_path, 'wb') as w:
pickle.dump(data_dict, w, protocol=4)
train_logger.info("data_dict saved: {}".format(save_data_path))
