def evaluate(sess,query,doc):
data_len = len(query)
query_len = data_len/config.unit_size
batch_val = batch_iter(query,doc,config.batch_size,config.unit_size)
total_loss = 0.0
total_p_1 = 0.0
total_mrr = 0.0
for val_query,val_doc in batch_val:
loss,p_1,mrr = sess.run([model.loss,model.p_1,model.mrr],feed_dict=feed_data(val_query,val_doc))
total_loss += loss*64
total_p_1 += p_1*64
total_mrr += mrr*64
return total_loss/query_len,total_p_1/query_len,total_mrr/query_len
#encoding:utf-8 import load_data from config import TextConfig as config #参数 filename = config.filename vocab_dir = config.vocab_dir vocab_size = config.vocab_size #读取，分词 contents, labels = load_data.read_file_seg(filename) #建立词典 load_data.build_vocab(filename, vocab_dir, vocab_size) #词ID，类别ID _, word_to_id = load_data.read_vocab(vocab_dir) _, cat_to_id = load_data.read_category() #生成向量 x, y = load_data.process_file(filename, word_to_id, cat_to_id, max_length=600) a = load_data.batch_iter(x, y, 10) #load_data函数里面所有包含filename为参数的函数，都应该优化 #实现，运行load_data生成词典，词向量，引用直接加载训练好的模型就可以
print(
"++++++++++++++++++dev++++++++++++++{}: step {}, loss {:g}, acc {:g}"
.format(time_str, step, cost, accuracy))
if writer:
writer.add_summary(summaries, step)
# for epoch in range(FLAGS.num_epochs):
# print('current epoch %s' % (epoch + 1))
# for i in range(0, 200000, FLAGS.batch_size):
# x = train_x[i:i + FLAGS.batch_size]
# y = train_y[i:i + FLAGS.batch_size]
# step = train_step(x, y)
# if step % FLAGS.evaluate_every == 0:
# dev_step(dev_x[0: 100], dev_y[0: 100], dev_summary_writer)
batches = batch_iter(list(zip(train_x, train_y)), FLAGS.batch_size,
FLAGS.num_epochs)
for batch in batches:
# print (batch[0])
x_batch, y_batch = zip(
*batch) # x_batch = 64 * 30 * 30 y_batch = 64 * 5
train_step(x_batch, y_batch)
current_step = tf.train.global_step(sess, global_step)
if current_step % FLAGS.evaluate_every == 0: # 100次
print("\nEvaluation:")
dev_step(dev_x[0:2000], dev_y[0:2000], writer=dev_summary_writer)
print("")
if current_step % FLAGS.checkpoint_every == 0: # 100次
path = saver.save(sess,
checkpoint_prefix,
global_step=current_step)
def train():
word_2_id = read_vocab(vocab_dir)
query_train,doc_train = process_file(train_query_dir,train_docs_dir,word_2_id)
query_val,doc_val = process_file(val_query_dir,val_docs_dir,word_2_id)
# 配置Tensorboard，重新训练时需要将文件夹删除，不然会覆盖
tb_dir = './tensorboard/mvlstm-'+config.interaction
if not os.path.exists(tb_dir):
os.makedirs(tb_dir)
tf.summary.scalar('loss',model.loss)
tf.summary.scalar('p@1',model.p_1)
tf.summary.scalar('MRR',model.mrr)
merged = tf.summary.merge_all()
# 配置 Saver
saver = tf.train.Saver()
if not os.path.exists(save_dir):
os.makedirs(save_dir)
sess = tf.Session()
train_writer = tf.summary.FileWriter(tb_dir + '/train', sess.graph)
val_writer = tf.summary.FileWriter(tb_dir + '/test',sess.graph)
sess.run(tf.global_variables_initializer())
#writer.add_graph(sess.graph)
best_val = 0.0
total_batch = 0
print('Training and Evaluation...')
for epoch in tqdm(range(config.num_epochs)):
print('Epoch:', epoch + 1)
batch_train = batch_iter(query_train,doc_train,config.batch_size,config.unit_size)
for query_batch,doc_batch in batch_train:
feed_dict =feed_data(query_batch, doc_batch)
val_feed = feed_data(query_val,doc_val)
if total_batch%config.save_per_batch==0:
s = sess.run(merged,feed_dict=feed_dict)
train_writer.add_summary(s,total_batch)
if total_batch%100==0:
train_loss, train_p_1, train_mrr,y_pred= sess.run([model.loss, model.p_1, model.mrr,model.y_pred],feed_dict=feed_dict)
val_loss, val_p_1, val_mrr = evaluate(sess, query_val, doc_val)
s = sess.run(merged,feed_dict=val_feed)
val_writer.add_summary(s,total_batch)
#print(y_pred)
#print(type(y_pred))
#print(y_pred.shape)
if val_p_1 >best_val:
best_val = val_p_1
saver.save(sess,save_path)
improved_str='*'
else:
improved_str=''
msg = 'Iter: {0:>6}, Train Loss: {1:>6.2}, Train p@1: {2:>7.2%}, Train MRR: {3:>7.2%} , Val Loss: {4:>6.2}, Val p@1: {5:>7.2%}, Val MRR: {6:>4.2%} {7}'
print(msg.format(total_batch, train_loss, train_p_1, train_mrr,val_loss, val_p_1, val_mrr,improved_str))
sess.run(model.optmz,feed_dict=feed_dict)
total_batch+=1
Evaluates model on a dev set
"""
feed_dict = {cnn.input_u: u_batch, cnn.input_i: i_batch, cnn.input_y: y_batch, cnn.dropout_keep_prob: 1.0}
step, summaries, loss, accuracy, mae, rmse = sess.run(
[global_step, dev_summary_op, cnn.loss, cnn.accuracy, cnn.mae, cnn.rmse], feed_dict
)
time_str = datetime.datetime.now().isoformat()
print(
"{}: step {}, loss {:g}, acc {:g}, mae {:g}, rmse {:g}".format(
time_str, step, loss, accuracy, mae, rmse
)
)
if writer:
writer.add_summary(summaries, step)
# Generate batches
batches = batch_iter(zip(u_train, i_train, y_train), FLAGS.batch_size, FLAGS.num_epochs)
# Training loop. For each batch...
for batch in batches:
u_batch, i_batch, y_batch = zip(*batch)
# print u_batch, i_batch, y_batch
train_step(u_batch, i_batch, y_batch)
current_step = tf.train.global_step(sess, global_step)
if current_step % FLAGS.evaluate_every == 0:
print("\nEvaluation:")
dev_step(u_dev, i_dev, y_dev, writer=dev_summary_writer)
print("")
if current_step % FLAGS.checkpoint_every == 0:
path = saver.save(sess, checkpoint_prefix, global_step=current_step)
print("Saved model checkpoint to {}\n".format(path))
cnn.input_y: y_batch,
cnn.dropout_keep_prob: 1.0
}
step, summaries, loss, accuracy, mae, rmse = sess.run([
global_step, dev_summary_op, cnn.loss, cnn.accuracy, cnn.mae,
cnn.rmse
], feed_dict)
time_str = datetime.datetime.now().isoformat()
print(
"{}: step {}, loss {:g}, acc {:g}, mae {:g}, rmse {:g}".format(
time_str, step, loss, accuracy, mae, rmse))
if writer:
writer.add_summary(summaries, step)
# Generate batches
batches = batch_iter(zip(u_train, i_train, y_train), FLAGS.batch_size,
FLAGS.num_epochs)
# Training loop. For each batch...
for batch in batches:
u_batch, i_batch, y_batch = zip(*batch)
# print u_batch, i_batch, y_batch
train_step(u_batch, i_batch, y_batch)
current_step = tf.train.global_step(sess, global_step)
if current_step % FLAGS.evaluate_every == 0:
print("\nEvaluation:")
dev_step(u_dev, i_dev, y_dev, writer=dev_summary_writer)
print("")
if current_step % FLAGS.checkpoint_every == 0:
path = saver.save(sess,
checkpoint_prefix,
global_step=current_step)
print("Saved model checkpoint to {}\n".format(path))
feed_dict = {
cnn.input_x: x_batch,
cnn.input_y: y_batch,
cnn.dropout_keep_prob: 1.0
}
step, summaries, loss, accuracy = sess.run(
[global_step, dev_summary_op, cnn.loss, cnn.accuracy],
feed_dict)
time_str = datetime.datetime.now().isoformat()
print("{}: step {}, loss {:g}, acc {:g}".format(
time_str, step, loss, accuracy))
if writer:
writer.add_summary(summaries, step)
# Generate batches
batches = load_data.batch_iter(list(zip(x_train, y_train)),
FLAGS.batch_size, FLAGS.num_epochs)
# Training loop. For each batch...
for batch in batches:
x_batch, y_batch = zip(*batch)
train_step(x_batch, y_batch)
current_step = tf.train.global_step(sess, global_step)
if current_step % FLAGS.evaluate_every == 0:
print("\nEvaluation:")
dev_step(x_dev, y_dev, writer=dev_summary_writer)
print("")
if current_step % FLAGS.checkpoint_every == 0:
path = saver.save(sess,
checkpoint_prefix,
global_step=current_step)
print("Saved model checkpoint to {}\n".format(path))
def train():
# load data
data, labels = load_data.extract_data('linearly_separable_data.csv')
# creating testing and training set
X_train, X_test, Y_train, Y_test = train_test_split(data,
labels,
test_size=0.25)
train_data_node = tf.placeholder(tf.float32, shape=(None, 2))
train_label_node = tf.placeholder(tf.float32, shape=(None, 1))
# weight
W = tf.Variable(tf.random_uniform([2, 1], -1.0, 1.0), name="W")
b = tf.Variable(tf.zeros([1]))
# y_value = [batch_size,1]
y_value = tf.matmul(train_data_node, W) + b
weight_loss = 0.5 * tf.reduce_sum(tf.square(W))
hinge_loss = tf.reduce_sum(
tf.maximum(tf.zeros([BATCH_SIZE, 1]), 1 - train_label_node * y_value))
svm_loss = weight_loss + svmC * hinge_loss
# for test
hinge_loss_test = tf.reduce_sum(
tf.maximum(tf.zeros([Test_Size, 1]), 1 - train_label_node * y_value))
svm_loss_test = weight_loss + svmC * hinge_loss_test
# train
global_step = tf.Variable(0, name="global_step", trainable=False)
optimizer = tf.train.AdamOptimizer(1e-3)
grads_and_vars = optimizer.compute_gradients(svm_loss)
train_op = optimizer.apply_gradients(grads_and_vars,
global_step=global_step)
# evaluation
predicted_class = tf.sign(y_value)
correct_prediction = tf.equal(train_label_node, predicted_class)
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
# runing the training
with tf.Session() as sess:
tf.initialize_all_variables().run()
print('Initialized!')
# generate batches
batches = load_data.batch_iter(list(zip(X_train, Y_train)), BATCH_SIZE,
NUM_EPOCHS)
# batch count
batch_count = 0
epoch = 1
print("Epoch " + str(epoch) + ":")
for batch in batches:
batch_count += 1
# train process
x_batch, y_batch = zip(*batch)
feed_dict = {train_data_node: x_batch, train_label_node: y_batch}
_, step, losses = sess.run([train_op, global_step, svm_loss],
feed_dict=feed_dict)
# test process
if (batch_count * BATCH_SIZE) % Train_Size == 0:
epoch += 1
print("Epoch " + str(epoch) + ":")
if batch_count % EVAL_FREQUENCY == 0:
feed_dict = {train_data_node: X_test, train_label_node: Y_test}
step, losses, acc = sess.run(
[global_step, svm_loss_test, accuracy],
feed_dict=feed_dict)
time_str = datetime.datetime.now().isoformat()
print("{}: step {}, loss {:g}, acc {:g}".format(
time_str, step, losses, acc))