for connection in connections:
conn.append(
connection.replace('nc', '').strip(' ').replace(':',
' ').split(' '))
else:
conn = ''
if ctf_challs["files"]:
files = ctf_challs["files.split(',')"]
else:
files = [""]
if ctf_challs["category"]:
category = ctf_challs["category"]
else:
category = ''
if ctf_challs["points"]:
points = ctf_challs["points"]
else:
points = ''
if ctf_challs["links"]:
links = helper.sanitise(ctf_challs["links"])
else:
links = ''
if ctf_challs["tags"]:
tags = helper.sanitise(ctf_challs["tags"])
else:
tags = ''
Readme = helper.genWriteup(name, conn, files, desc, category, points, links,
tags)
helper.prepare(name, Readme, category, files, conn)
def dev_point_wise():
if FLAGS.data == 'TREC' or FLAGS.data == 'sst2':
train, dev, test = load_trec_sst2(FLAGS.data)
else:
train, dev = load(FLAGS.data)
q_max_sent_length = max(
map(lambda x: len(x), train['question'].str.split()))
print(q_max_sent_length)
print(len(train))
print('train question unique:{}'.format(len(train['question'].unique())))
print('train length', len(train))
print('dev length', len(dev))
if FLAGS.data == 'TREC' or FLAGS.data == 'sst2':
alphabet, embeddings = prepare([train, dev, test],
max_sent_length=q_max_sent_length,
dim=FLAGS.embedding_dim,
is_embedding_needed=True,
fresh=True)
else:
alphabet, embeddings = prepare([train, dev],
max_sent_length=q_max_sent_length,
dim=FLAGS.embedding_dim,
is_embedding_needed=True,
fresh=True)
print('alphabet:', len(alphabet))
with tf.Graph().as_default():
with tf.device("/gpu:0"):
session_conf = tf.ConfigProto()
session_conf.allow_soft_placement = FLAGS.allow_soft_placement
session_conf.log_device_placement = FLAGS.log_device_placement
session_conf.gpu_options.allow_growth = True
sess = tf.Session(config=session_conf)
now = int(time.time())
timeArray = time.localtime(now)
timeStamp1 = time.strftime("%Y%m%d%H%M%S", timeArray)
timeDay = time.strftime("%Y%m%d", timeArray)
print(timeStamp1)
with sess.as_default(), open(precision, "w") as log:
log.write(str(FLAGS.__flags) + '\n')
cnn = CNN(max_input_left=q_max_sent_length,
vocab_size=len(alphabet),
embeddings=embeddings,
embedding_size=FLAGS.embedding_dim,
batch_size=FLAGS.batch_size,
filter_sizes=list(map(int,
FLAGS.filter_sizes.split(","))),
num_filters=FLAGS.num_filters,
l2_reg_lambda=FLAGS.l2_reg_lambda,
is_Embedding_Needed=True,
trainable=FLAGS.trainable,
dataset=FLAGS.data,
extend_feature_dim=FLAGS.extend_feature_dim)
cnn.build_graph()
global_step = tf.Variable(0, name="global_step", trainable=False)
optimizer = tf.train.AdamOptimizer(FLAGS.learning_rate)
grads_and_vars = optimizer.compute_gradients(cnn.loss)
train_op = optimizer.apply_gradients(grads_and_vars,
global_step=global_step)
sess.run(tf.global_variables_initializer())
acc_max = 0.0000
for i in range(FLAGS.num_epochs):
datas = batch_gen_with_point_wise(train,
alphabet,
FLAGS.batch_size,
q_len=q_max_sent_length)
for data in datas:
feed_dict = {
cnn.question: data[0],
cnn.input_y: data[1],
cnn.q_position: data[2],
cnn.dropout_keep_prob: FLAGS.dropout_keep_prob
}
_, step, loss, accuracy = sess.run(
[train_op, global_step, cnn.loss, cnn.accuracy],
feed_dict)
time_str = datetime.datetime.now().isoformat()
print("{}: step {}, loss {:g}, acc {:g} ".format(
time_str, step, loss, accuracy))
predicted = predict(sess, cnn, train, alphabet,
FLAGS.batch_size, q_max_sent_length)
predicted_label = np.argmax(predicted, 1)
acc_train = accuracy_score(predicted_label, train['flag'])
predicted_dev = predict(sess, cnn, dev, alphabet,
FLAGS.batch_size, q_max_sent_length)
predicted_label = np.argmax(predicted_dev, 1)
acc_dev = accuracy_score(predicted_label, dev['flag'])
if acc_dev > acc_max:
tf.train.Saver().save(sess,
"model_save/model",
write_meta_graph=True)
acc_max = acc_dev
print("{}:train epoch:acc {}".format(i, acc_train))
print("{}:dev epoch:acc {}".format(i, acc_dev))
line2 = " {}:epoch: acc{}".format(i, acc_dev)
log.write(line2 + '\n')
log.flush()
acc_flod.append(acc_max)
log.close()
logger = logging.getLogger(program)
#%% 获得配置
FLAGS = config.flags.FLAGS
opts = FLAGS.flag_values_dict()
for item in opts:
logger.info('{} : {}'.format(item, opts[item]))
#%%
############## 数据载入 #################
logger.info('load data ...........')
train, dev, test = helper.load(opts['data_dir'])
max_sent_length = max(map(lambda x: len(x), train['question'].str.split()))
max_sent_length = 33
#%%
############## 数据预处理 ###############
alphabet, embeddings, = helper.prepare([train, test, dev],
dim=opts['embedding_dim'])
#%%
############## 模型 #################
opts['embeddings'] = embeddings
opts['max_input_sentence'] = max_sent_length
opts['vocab_size'] = len(alphabet)
def embedding_look_up(data, embedding):
new_data = []
for _, d in enumerate(data):
emb = [embedding[i] for i in d]
new_data.append(emb)
return np.array(new_data)
if __name__ == '__main__':
if FLAGS.data == 'TREC' or FLAGS.data == 'sst2':
for attr, value in sorted(FLAGS.__flags.items()):
print(("{}={}".format(attr.upper(), value)))
dev_point_wise()
ckpt = tf.train.get_checkpoint_state("model_save" + '/')
saver = tf.train.import_meta_graph(ckpt.model_checkpoint_path +
'.meta')
train, dev, test = load_trec_sst2(FLAGS.data)
q_max_sent_length = max(
map(lambda x: len(x), train['question'].str.split()))
alphabet, embeddings = prepare([train, test, dev],
max_sent_length=q_max_sent_length,
dim=FLAGS.embedding_dim,
is_embedding_needed=True,
fresh=True)
with tf.Session() as sess:
saver.restore(sess, ckpt.model_checkpoint_path)
graph = tf.get_default_graph()
scores = []
question = graph.get_operation_by_name('input_question').outputs[0]
q_position = graph.get_operation_by_name('q_position').outputs[0]
dropout_keep_prob = graph.get_operation_by_name(
'dropout_keep_prob').outputs[0]
for data in batch_gen_with_single(test, alphabet, FLAGS.batch_size,
q_max_sent_length):
feed_dict = {
question.name: data[0],
q_position.name: data[1],
def test_pair_wise(dns=FLAGS.dns):
train, test, dev = load(FLAGS.data, filter=FLAGS.clean)
# train = train[:10000]
# test = test[:10000]
# dev = dev[:10000]
# submit = submit[:1000]
q_max_sent_length = max(
map(lambda x: len(x), train['question'].str.split()))
a_max_sent_length = max(map(lambda x: len(x), train['answer'].str.split()))
print 'q_question_length:{} a_question_length:{}'.format(
q_max_sent_length, a_max_sent_length)
print 'train question unique:{}'.format(len(train['question'].unique()))
print 'train length', len(train)
print 'test length', len(test)
print 'dev length', len(dev)
alphabet, embeddings = prepare([train, test, dev],
dim=FLAGS.embedding_dim,
is_embedding_needed=True,
fresh=FLAGS.fresh)
# alphabet,embeddings = prepare_300([train,test,dev])
print 'alphabet:', len(alphabet)
with tf.Graph().as_default(), tf.device("/gpu:" + str(FLAGS.gpu)):
# with tf.device("/cpu:0"):
session_conf = tf.ConfigProto()
session_conf.allow_soft_placement = FLAGS.allow_soft_placement
session_conf.log_device_placement = FLAGS.log_device_placement
session_conf.gpu_options.allow_growth = True
sess = tf.Session(config=session_conf)
with sess.as_default(), open(precision, "w") as log:
log.write(str(FLAGS.__flags) + '\n')
folder = 'runs/' + timeDay + '/' + timeStamp + '/'
out_dir = folder + FLAGS.data
if not os.path.exists(folder):
os.makedirs(folder)
# train,test,dev = load("trec",filter=True)
# alphabet,embeddings = prepare([train,test,dev],is_embedding_needed = True)
print "start build model"
cnn = QA_RNN_extend(max_input_left=q_max_sent_length,
max_input_right=a_max_sent_length,
batch_size=FLAGS.batch_size,
vocab_size=len(alphabet),
embedding_size=FLAGS.embedding_dim,
filter_sizes=list(
map(int, FLAGS.filter_sizes.split(","))),
num_filters=FLAGS.num_filters,
dropout_keep_prob=FLAGS.dropout_keep_prob,
embeddings=embeddings,
l2_reg_lambda=FLAGS.l2_reg_lambda,
overlap_needed=FLAGS.overlap_needed,
learning_rate=FLAGS.learning_rate,
trainable=FLAGS.trainable,
extend_feature_dim=FLAGS.extend_feature_dim,
pooling=FLAGS.pooling,
position_needed=FLAGS.position_needed,
conv=FLAGS.conv)
cnn.build_graph()
saver = tf.train.Saver(tf.global_variables(), max_to_keep=20)
train_writer = tf.summary.FileWriter(log_dir + '/train',
sess.graph)
test_writer = tf.summary.FileWriter(log_dir + '/test')
# Initialize all variables
print "build over"
sess.run(tf.global_variables_initializer())
print "variables_initializer"
map_max = 0.65
for i in range(FLAGS.num_epochs):
if FLAGS.dns == True:
samples = dns_sample(train,
alphabet,
q_max_sent_length,
a_max_sent_length,
sess,
cnn,
FLAGS.batch_size,
neg_sample_num=10)
datas = batch_gen_with_pair_dns(samples, FLAGS.batch_size)
print 'load dns datas'
for data in datas:
feed_dict = {
cnn.question: data[0],
cnn.answer: data[1],
cnn.answer_negative: data[2]
}
_, step, loss, accuracy, score12, score13 = sess.run([
cnn.train_op, cnn.global_step, cnn.loss,
cnn.accuracy, cnn.score12, cnn.score13
], feed_dict)
time_str = datetime.datetime.now().isoformat()
print(
"{}: step {}, loss {:g}, acc {:g} ,positive {:g},negative {:g}"
.format(time_str, step, loss, accuracy,
np.mean(score12), np.mean(score13)))
line = "{}: step {}, loss {:g}, acc {:g} ,positive {:g},negative {:g}".format(
time_str, step, loss, accuracy, np.mean(score12),
np.mean(score13))
else:
d = get_overlap_dict(train,
alphabet,
q_len=q_max_sent_length,
a_len=a_max_sent_length)
datas = batch_gen_with_pair_overlap(
train,
alphabet,
FLAGS.batch_size,
q_len=q_max_sent_length,
a_len=a_max_sent_length,
fresh=FLAGS.fresh,
overlap_dict=d)
print "load data"
for data in datas:
feed_dict = {
cnn.question: data[0],
cnn.answer: data[1],
cnn.answer_negative: data[2],
cnn.q_pos_overlap: data[3],
cnn.q_neg_overlap: data[4],
cnn.a_pos_overlap: data[5],
cnn.a_neg_overlap: data[6],
cnn.q_position: data[7],
cnn.a_pos_position: data[8],
cnn.a_neg_position: data[9]
}
_, summary, step, loss, accuracy, score12, score13 = sess.run(
[
cnn.train_op, cnn.merged, cnn.global_step,
cnn.loss, cnn.accuracy, cnn.score12,
cnn.score13
], feed_dict)
train_writer.add_summary(summary, i)
time_str = datetime.datetime.now().isoformat()
print(
"{}: step {}, loss {:g}, acc {:g} ,positive {:g},negative {:g}"
.format(time_str, step, loss, accuracy,
np.mean(score12), np.mean(score13)))
line = "{}: step {}, loss {:g}, acc {:g} ,positive {:g},negative {:g}".format(
time_str, step, loss, accuracy, np.mean(score12),
np.mean(score13))
# print loss
if i % 1 == 0:
predicted_dev = predict(sess, cnn, dev, alphabet,
FLAGS.batch_size,
q_max_sent_length,
a_max_sent_length)
map_mrr_dev = evaluation.evaluationBypandas(
dev, predicted_dev)
predicted_test = predict(sess, cnn, test, alphabet,
FLAGS.batch_size,
q_max_sent_length,
a_max_sent_length)
map_mrr_test = evaluation.evaluationBypandas(
test, predicted_test)
print "{}:epoch:dev map mrr {}".format(i, map_mrr_dev)
print "{}:epoch:test map mrr {}".format(i, map_mrr_test)
line = " {}:epoch: map_dev{}-------map_mrr_test{}".format(
i, map_mrr_dev[0], map_mrr_test)
if map_mrr_dev[0] > map_max:
map_max = map_mrr_dev[0]
# timeStamp = time.strftime("%Y%m%d%H%M%S", time.localtime(int(time.time())))
save_path = saver.save(sess, out_dir)
print "Model saved in file: ", save_path
log.write(line + '\n')
log.flush()
print 'train over'
saver.restore(sess, out_dir)
predicted = predict(sess, cnn, train, alphabet, FLAGS.batch_size,
q_max_sent_length, a_max_sent_length)
train['predicted'] = predicted
train['predicted'].to_csv('train.QApair.TJU_IR_QA2017_train.score',
index=False,
sep='\t')
map_mrr_train = evaluation.evaluationBypandas(train, predicted)
predicted_dev = predict(sess, cnn, dev, alphabet, FLAGS.batch_size,
q_max_sent_length, a_max_sent_length)
dev['predicted'] = predicted_dev
dev['predicted'].to_csv('train.QApair.TJU_IR_QA2017_dev.score',
index=False,
sep='\t')
map_mrr_dev = evaluation.evaluationBypandas(dev, predicted_dev)
predicted_test = predict(sess, cnn, test, alphabet,
FLAGS.batch_size, q_max_sent_length,
a_max_sent_length)
test['predicted'] = predicted_test
test['predicted'].to_csv('train.QApair.TJU_IR_QA2017.score',
index=False,
sep='\t')
map_mrr_test = evaluation.evaluationBypandas(test, predicted_test)
print 'map_mrr train', map_mrr_train
print 'map_mrr dev', map_mrr_dev
print 'map_mrr test', map_mrr_test
log.write(str(map_mrr_train) + '\n')
log.write(str(map_mrr_test) + '\n')
log.write(str(map_mrr_dev) + '\n')
predict(sess, cnn, train[:100], alphabet, 20, q_max_sent_length,
a_max_sent_length)
def test_point_wise():
train, dev, test = load(FLAGS.data, filter=FLAGS.clean) # wiki
# train, test, dev = load(FLAGS.data, filter=FLAGS.clean) #trec
q_max_sent_length = max(map(lambda x: len(x),
test['question'].str.split()))
a_max_sent_length = 2
print(q_max_sent_length)
print(len(train))
print('train question unique:{}'.format(len(train['question'].unique())))
print('train length', len(train))
print('test length', len(test))
print('dev length', len(dev))
alphabet, embeddings = prepare([train, test, dev],
max_sent_length=q_max_sent_length,
dim=FLAGS.embedding_dim,
is_embedding_needed=True,
fresh=True)
print('alphabet:', len(alphabet))
with tf.Graph().as_default():
with tf.device("/gpu:0"):
# session_conf = tf.ConfigProto(
# allow_soft_placement=FLAGS.allow_soft_placement,
# log_device_placement=FLAGS.log_device_placement)
session_conf = tf.ConfigProto()
session_conf.allow_soft_placement = FLAGS.allow_soft_placement
session_conf.log_device_placement = FLAGS.log_device_placement
session_conf.gpu_options.allow_growth = True
sess = tf.Session(config=session_conf)
now = int(time.time())
timeArray = time.localtime(now)
timeStamp1 = time.strftime("%Y%m%d%H%M%S", timeArray)
timeDay = time.strftime("%Y%m%d", timeArray)
print(timeStamp1)
with sess.as_default(), open(precision, "w") as log:
log.write(str(FLAGS.__flags) + '\n')
# train,test,dev = load("trec",filter=True)
# alphabet,embeddings = prepare([train,test,dev],is_embedding_needed = True)
cnn = BiLSTM(max_input_left=q_max_sent_length,
vocab_size=len(alphabet),
embeddings=embeddings,
embedding_size=FLAGS.embedding_dim,
batch_size=FLAGS.batch_size,
filter_sizes=list(
map(int, FLAGS.filter_sizes.split(","))),
num_filters=FLAGS.num_filters,
l2_reg_lambda=FLAGS.l2_reg_lambda,
is_Embedding_Needed=True,
trainable=FLAGS.trainable,
overlap_needed=FLAGS.overlap_needed,
position_needed=FLAGS.position_needed,
pooling=FLAGS.pooling,
hidden_num=FLAGS.hidden_num,
extend_feature_dim=FLAGS.extend_feature_dim)
cnn.build_graph()
# Define Training procedure
global_step = tf.Variable(0, name="global_step", trainable=False)
optimizer = tf.train.AdamOptimizer(FLAGS.learning_rate)
grads_and_vars = optimizer.compute_gradients(cnn.loss)
train_op = optimizer.apply_gradients(grads_and_vars,
global_step=global_step)
saver = tf.train.Saver(tf.global_variables(), max_to_keep=20)
sess.run(tf.global_variables_initializer())
map_max = 0.65
for i in range(FLAGS.num_epochs):
datas = batch_gen_with_point_wise(train,
alphabet,
FLAGS.batch_size,
q_len=q_max_sent_length,
a_len=a_max_sent_length)
for data in datas:
feed_dict = {
cnn.question: data[0],
cnn.input_y: data[1],
cnn.q_position: data[2],
cnn.dropout_keep_prob: FLAGS.dropout_keep_prob
}
_, step, loss, accuracy = sess.run(
[train_op, global_step, cnn.loss, cnn.accuracy],
feed_dict)
time_str = datetime.datetime.now().isoformat()
print("{}: step {}, loss {:g}, acc {:g} ".format(
time_str, step, loss, accuracy))
now = int(time.time())
timeArray = time.localtime(now)
timeStamp = time.strftime("%Y%m%d%H%M%S", timeArray)
timeDay = time.strftime("%Y%m%d", timeArray)
print(timeStamp1)
print(timeStamp)
predicted = predict(sess, cnn, train, alphabet,
FLAGS.batch_size, q_max_sent_length,
a_max_sent_length)
predicted_label = np.argmax(predicted, 1)
map_mrr_train = evaluation.evaluationBypandas_f1_acc(
train, predicted[:, -1], predicted_label)
predicted_test = predict(sess, cnn, test, alphabet,
FLAGS.batch_size, q_max_sent_length,
a_max_sent_length)
predicted_label = np.argmax(predicted_test, 1)
map_mrr_test = evaluation.evaluationBypandas_f1_acc(
test, predicted_test[:, -1], predicted_label)
if map_mrr_test[0] > map_max:
map_max = map_mrr_test[0]
timeStamp = time.strftime("%Y%m%d%H%M%S",
time.localtime(int(time.time())))
folder = 'runs/' + timeDay
out_dir = folder + '/' + timeStamp + \
'__' + FLAGS.data + str(map_mrr_test[0])
if not os.path.exists(folder):
os.makedirs(folder)
#save_path = saver.save(sess, out_dir)
print("{}:train epoch:map mrr {}".format(i, map_mrr_train))
print("{}:test epoch:map mrr {}".format(i, map_mrr_test))
line2 = " {}:epoch: map_test{}".format(i, map_mrr_test)
log.write(line2 + '\n')
log.flush()
log.close()
logger = logging.getLogger(program)
# 获得配置
FLAGS = config.flags.FLAGS
# FLAGS._parse_flags()
opts = FLAGS.flag_values_dict()
for item in opts:
logger.info('{} : {}'.format(item, opts[item]))
############## 数据载入 #################
logger.info('load data ...........')
train,dev,test = helper.load(opts['data_dir'])
max_sent_length = max(map(lambda x: len(x), train['question'].str.split()))
max_sent_length = 33
############## 数据预处理 ###############
alphabet, embeddings,embeddings_complex = helper.prepare(
[train, test, dev],dim=FLAGS.embedding_dim)
############## 模型预测 #################
opts['embeddings'] = embeddings
opts['max_input_sentence'] = max_sent_length
opts['vocab_size'] = len(alphabet)
with tf.Graph().as_default():
model = Fasttext(opts)
model._model_stats()
for i in range(opts['num_epochs']):
data_gen = helper.batch_iter(train,opts['batch_size'],alphabet,True,sen_len=max_sent_length)
model._train(data_gen,i)
# 测试代码
def test_point_wise():
train, test, dev = load(FLAGS.data, filter=FLAGS.clean)
train = train.fillna('')
test = test.fillna('')
dev = dev.fillna('')
# submit = submit.fillna('')
q_max_sent_length = max(
map(lambda x: len(x), train['question'].str.split()))
a_max_sent_length = max(map(lambda x: len(x), train['answer'].str.split()))
# train = train[:1000]
# test = test[:1000]
# dev = dev[:1000]
# submit = dev[:100]
print 'train question unique:{}'.format(len(train['question'].unique()))
print 'train length', len(train)
print 'test length', len(test)
print 'dev length', len(dev)
alphabet, embeddings = prepare([train, test, dev],
dim=FLAGS.embedding_dim,
is_embedding_needed=True,
fresh=True)
print 'alphabet:', len(alphabet)
with tf.Graph().as_default():
with tf.device("/gpu:0"):
# session_conf = tf.ConfigProto(
# allow_soft_placement=FLAGS.allow_soft_placement,
# log_device_placement=FLAGS.log_device_placement)
session_conf = tf.ConfigProto()
session_conf.allow_soft_placement = FLAGS.allow_soft_placement
session_conf.log_device_placement = FLAGS.log_device_placement
session_conf.gpu_options.allow_growth = True
sess = tf.Session(config=session_conf)
with sess.as_default(), open(precision, "w") as log:
log.write(str(FLAGS.__flags) + '\n')
# train,test,dev = load("trec",filter=True)
# alphabet,embeddings = prepare([train,test,dev],is_embedding_needed = True)
cnn = QA(max_input_left=q_max_sent_length,
max_input_right=a_max_sent_length,
vocab_size=len(alphabet),
embedding_size=FLAGS.embedding_dim,
batch_size=FLAGS.batch_size,
embeddings=embeddings,
dropout_keep_prob=FLAGS.dropout_keep_prob,
filter_sizes=list(map(int,
FLAGS.filter_sizes.split(","))),
num_filters=FLAGS.num_filters,
l2_reg_lambda=FLAGS.l2_reg_lambda,
is_Embedding_Needed=True,
trainable=FLAGS.trainable,
overlap_needed=FLAGS.overlap_needed,
position_needed=FLAGS.position_needed,
pooling=FLAGS.pooling,
extend_feature_dim=FLAGS.extend_feature_dim)
cnn.build_graph()
# Define Training procedure
global_step = tf.Variable(0, name="global_step", trainable=False)
starter_learning_rate = 0.001
learning_rate = tf.train.exponential_decay(starter_learning_rate,
global_step, 100, 0.96)
optimizer = tf.train.AdamOptimizer(learning_rate)
grads_and_vars = optimizer.compute_gradients(cnn.loss)
train_op = optimizer.apply_gradients(grads_and_vars,
global_step=global_step)
saver = tf.train.Saver(tf.global_variables(), max_to_keep=20)
# Initialize all variables
sess.run(tf.global_variables_initializer())
# seq_process(train, alphabet)
# seq_process(test, alphabet)
map_max = 0.65
for i in range(30):
d = get_overlap_dict(train,
alphabet,
q_len=q_max_sent_length,
a_len=a_max_sent_length)
datas = batch_gen_with_point_wise(train,
alphabet,
FLAGS.batch_size,
overlap_dict=d,
q_len=q_max_sent_length,
a_len=a_max_sent_length)
for data in datas:
feed_dict = {
cnn.question: data[0],
cnn.answer: data[1],
cnn.input_y: data[2],
cnn.q_overlap: data[3],
cnn.a_overlap: data[4],
cnn.q_position: data[5],
cnn.a_position: data[6]
}
_, step, loss, accuracy, pred, scores, see = sess.run([
train_op, global_step, cnn.loss, cnn.accuracy,
cnn.predictions, cnn.scores, cnn.see
], feed_dict)
time_str = datetime.datetime.now().isoformat()
print("{}: step {}, loss {:g}, acc {:g} ".format(
time_str, step, loss, accuracy))
# print loss
# predicted = predict(sess,cnn,train,alphabet,FLAGS.batch_size,q_max_sent_length,a_max_sent_length)
# map_mrr_train = evaluation.evaluationBypandas(train,predicted[:,-1])
predicted = predict(sess, cnn, dev, alphabet, FLAGS.batch_size,
q_max_sent_length, a_max_sent_length)
map_mrr_dev = evaluation.evaluationBypandas(
dev, predicted[:, -1])
predicted_test = predict(sess, cnn, test, alphabet,
FLAGS.batch_size, q_max_sent_length,
a_max_sent_length)
map_mrr_test = evaluation.evaluationBypandas(
test, predicted_test[:, -1])
if map_mrr_dev[0] > map_max:
map_max = map_mrr_dev[0]
timeStamp = time.strftime("%Y%m%d%H%M%S",
time.localtime(int(time.time())))
folder = 'runs/' + timeDay
out_dir = folder + '/' + timeStamp + '__' + FLAGS.data + str(
map_mrr_dev[0])
if not os.path.exists(folder):
os.makedirs(folder)
save_path = saver.save(sess, out_dir)
print "Model saved in file: ", save_path
# predicted = predict(sess,cnn,dev,alphabet,FLAGS.batch_size,q_max_sent_length,a_max_sent_length)
# map_mrr_dev = evaluation.evaluationBypandas(dev,predicted[:,-1])
# map_mrr_train = evaluation.evaluationBypandas(train,predicted_train[:,-1])
# print evaluation.evaluationBypandas(train,predicted_train[:,-1])
# print "{}:train epoch:map mrr {}".format(i,map_mrr_train)
print "{}:dev epoch:map mrr {}".format(i, map_mrr_dev)
print "{}:test epoch:map mrr {}".format(i, map_mrr_test)
# line = " {}:epoch: map_train{}----map_test{}----map_dev{}".format(i,map_mrr_train[0],map_mrr_test[0],map_mrr_dev[0])
line = " {}:epoch: map_dev{}----map_test{}".format(
i, map_mrr_dev[0], map_mrr_test[0])
log.write(line + '\n')
log.flush()
log.close()
