def test():
model = AttributeClassifier()
check_point = "checkpoint_AttA3_0.8810.pt"
model.load_model(check_point)
test_file = "data/attribute_test.txt"
test_texts = load_test_data(test_file)
f_w2v = "../embedding/embedding_all_merge_300.txt"
W, word2index = load_w2v(f_w2v)
f_dict = "../dataset/attribute.json"
attr_list, attr_dict = parse_json(f_dict)
test_data = Data((test_texts, None), word2index)
test_predict = train.predict(model.classifier, test_data, args)
print(test_predict)
fw = codecs.open("test_predict.txt", 'w', encoding='utf-8')
for p in test_predict:
attributes = []
for i, l in enumerate(p):
if l != 0:
attributes.append(attr_list[i])
fw.write('|'.join(attributes) + '\n')
def add_embedding(self):
if self.config.pre_trained == 'yes':
self.word2id, w2v = load_w2v(self.config.embedding_file, self.config.embedding_dim, False)
else:
self.word2id = load_word2id(self.config.word2id_file)
self.vocab_size = len(self.word2id) + 1
w2v = tf.random_uniform([self.vocab_size, self.config.embedding_dim], -1.0, 1.0)
if self.config.embedding_type == 'static':
self.embedding = tf.constant(w2v, dtype=tf.float32, name='word_embedding')
else:
self.embedding = tf.Variable(w2v, dtype=tf.float32, name='word_embedding')
inputs = tf.nn.embedding_lookup(self.embedding, self.x)
return inputs
def test():
# model = Classifier()
test_file1 = ROOT_DIR + "/attribute_level/data/attribute_test.txt"
test_file2 = ROOT_DIR + "/attribute_level/test_predict.txt"
test_texts, test_aspects = load_ab_test(test_file1, test_file2)
f_w2v = ROOT_DIR + "/embedding/embedding_all_merge_300.txt"
W, word2index = load_w2v(f_w2v)
f_dict1 = ROOT_DIR + "/dataset/polarity.json"
f_dict2 = ROOT_DIR + "/dataset/attribute.json"
polarity_list, polarity_dict = parse_json(f_dict1)
attr_list, attr_dict = parse_json(f_dict2)
assert len(test_texts) == len(test_aspects)
files = ["checkpoint_HEAT_0.7189.pt", "checkpoint_HEAT_0.7062.pt"]
predicts = []
for check_point in files:
predict = []
classifier = torch.load(check_point)
for text, aspect in zip(test_texts, test_aspects):
if aspect != '':
if aspect is None:
print("error")
test_data = Data3(([text], [None], [aspect]),
word2index,
polarity_dict,
args,
target_dict=attr_dict)
test_predict = train_single.predict(classifier, test_data,
args)
assert len(test_predict) == 1
polarity = str(test_predict[0].item() - 1)
else:
print(aspect)
print(text)
polarity = '0'
# fw.write(aspect+','+polarity+'\n')
predict.append(aspect + ',' + polarity)
predicts.append(predict)
print(len(predicts))
print(len(predicts[0]))
fw = codecs.open("test_predict_polarity_ensemble.txt",
'w',
encoding='utf-8')
for j in range(len(predicts[0])):
votes = [predicts[i][j] for i in range(len(predicts))]
voted = Counter(votes).most_common(1)
fw.write(voted + '\n')
def ensemble():
f_train = "../data/train.txt"
# f_test = "data/test_attr2.txt"
if args.w2v == "merge":
f_w2v = "../embedding/embedding_all_merge_300.txt"
elif args.w2v == "fasttext2":
f_w2v = "../embedding/embedding_all_fasttext2_300.txt"
elif args.w2v == "tencent":
f_w2v = "../embedding/embedding_all_tencent_200.txt"
else:
print("error, no embedding")
exit(-1)
f_dict = "../dataset/attribute.json"
print(f_train)
print(f_w2v)
if not os.path.exists("%s" % args.check_dir):
os.mkdir("%s" % args.check_dir)
raw_texts, raw_labels = load_attr_data(filename=f_train)
W, word2index2 = load_w2v(f_w2v)
word2index = pickle.load(open("../data/vocabulary.pkl", 'rb'))
assert word2index == word2index2
attr_list, attr_dict = parse_json(f_dict)
kf = 0
for train_index, test_index in kfold_split(len(raw_texts), args.folds):
kf += 1
print("FOLD:", kf)
print("TRAIN:", str(len(train_index)), '\n', "TEST:",
str(len(test_index)))
# train_index, test_index = train_index.tolist(), test_index.tolist()
test_texts, test_labels = [raw_texts[i] for i in test_index
], [raw_labels[i] for i in test_index]
train_texts, train_labels = [raw_texts[i] for i in train_index
], [raw_labels[i] for i in train_index]
print(len(train_texts))
print(len(test_labels))
model = AttributeClassifier()
print(attr_list)
print(attr_dict)
# exit(-1)
# print(train_texts)
model.train_from_data((train_texts, train_labels),
(test_texts, test_labels), W, word2index,
attr_dict, args, kf)
pass
def ensemble():
f_train = ROOT_DIR + "/data/train.txt"
if args.w2v == "merge":
f_w2v = ROOT_DIR + "/embedding/embedding_all_merge_300.txt"
elif args.w2v == "fasttext2":
f_w2v = ROOT_DIR + "/embedding/embedding_all_fasttext2_300.txt"
elif args.w2v == "tencent":
f_w2v = ROOT_DIR + "/embedding/embedding_all_tencent_200.txt"
else:
print("error, no embedding")
exit(-1)
f_dict1 = ROOT_DIR + "/dataset/polarity.json"
f_dict2 = ROOT_DIR + "/dataset/attribute.json"
print(f_train)
print(f_w2v)
if not os.path.exists("%s" % args.check_dir):
os.mkdir("%s" % args.check_dir)
W, word2index2 = load_w2v(f_w2v)
word2index = pickle.load(open(ROOT_DIR + "/data/vocabulary.pkl", 'rb'))
assert word2index == word2index2
polarity_list, polarity_dict = parse_json(f_dict1)
attr_list, attr_dict = parse_json(f_dict2)
kf = 0
fo = load_abp_raw(f_train)
for train_index, test_index in kfold_split(len(fo), args.folds):
kf += 1
print("FOLD:", kf)
# print("TRAIN:", train_index, '\n', "TEST:", test_index, str(len(test_index)))
train_texts, train_labels, train_aspects, test_texts, test_labels, test_aspects = splits(
fo, train_index, test_index)
print(len(train_texts))
print(len(test_texts))
# print(list(attr_dict.keys()))
model = Classifier()
print(attr_list)
print(attr_dict)
# exit(-1)
# print(train_texts)
model.train_from_data((train_texts, train_labels, train_aspects),
(test_texts, test_labels, test_aspects), W,
word2index, polarity_dict, attr_dict, args, kf)
def main():
f_train = ROOT_DIR + "/data/train.txt"
f_test = "data/test_p.txt"
if args.w2v == "merge":
f_w2v = ROOT_DIR + "/embedding/embedding_all_merge_300.txt"
elif args.w2v == "fasttext":
f_w2v = ROOT_DIR + "/embedding/embedding_all_fasttext_300.txt"
elif args.w2v == "fasttext2":
f_w2v = ROOT_DIR + "/embedding/embedding_all_fasttext2_300.txt"
elif args.w2v == "tencent":
f_w2v = ROOT_DIR + "/embedding/embedding_all_tencent_200.txt"
else:
print("error, no embedding")
exit(-1)
f_dict1 = ROOT_DIR + "/dataset/polarity.json"
f_dict2 = ROOT_DIR + "/dataset/attribute.json"
print(f_w2v)
# train_texts, train_labels = load_attr_data(filename=f_train)
# # test_text, test_labels = load_attr_data(filename=f_test)
# train_texts, train_labels, test_texts, test_labels = split_dev(train_texts, train_labels)
train_texts, train_labels, train_aspects, test_texts, test_labels, test_aspects = load_abp_data(
f_train, folds=5)
if not os.path.exists("%s" % args.check_dir):
os.mkdir("%s" % args.check_dir)
print(len(train_texts))
print(len(test_texts))
W, word2index2 = load_w2v(f_w2v)
word2index = pickle.load(open(ROOT_DIR + "/data/vocabulary.pkl", 'rb'))
assert word2index == word2index2
polarity_list, polarity_dict = parse_json(f_dict1)
attr_list, attr_dict = parse_json(f_dict2)
# print(list(attr_dict.keys()))
model = Classifier()
print(polarity_list)
print(polarity_dict)
# exit(-1)
# print(train_texts)
model.train_from_data((train_texts, train_labels, train_aspects),
(test_texts, test_labels, test_aspects), W,
word2index, polarity_dict, attr_dict, args)
def main():
f_train = "../data/train.txt"
# f_test = "data/test_attr2.txt"
if args.w2v == "merge":
f_w2v = "../embedding/embedding_all_merge_300.txt"
elif args.w2v == "fasttext":
f_w2v = "../embedding/embedding_all_fasttext_300.txt"
elif args.w2v == "fasttext2":
f_w2v = "../embedding/embedding_all_fasttext2_300.txt"
elif args.w2v == "tencent":
f_w2v = "../embedding/embedding_all_tencent_200.txt"
else:
print("error, no embedding")
exit(-1)
f_dict = "../dataset/attribute.json"
print(f_w2v)
train_texts, train_labels = load_attr_data(filename=f_train)
train_texts, train_labels, test_texts, test_labels = split_dev(
train_texts, train_labels)
print(len(train_texts))
print(len(test_labels))
# train_texts2, train_labels2, test_texts, test_labels = split_dev(train_texts, train_labels)
if not os.path.exists("%s" % args.check_dir):
os.mkdir("%s" % args.check_dir)
# test_texts, test_labels = load_attr_data(filename=f_test)
W, word2index2 = load_w2v(f_w2v)
word2index = pickle.load(open("../data/vocabulary.pkl", 'rb'))
assert word2index == word2index2
attr_list, attr_dict = parse_json(f_dict)
print(list(attr_dict.keys()))
model = AttributeClassifier()
print(attr_list)
print(attr_dict)
# exit(-1)
# print(train_texts)
model.train_from_data((train_texts, train_labels),
(test_texts, test_labels), W, word2index, attr_dict,
args)
def dev():
model = AttributeClassifier()
check_point = "checkpoints5/checkpoint_AttA3_0.8666.pt"
model.load_model(check_point)
f_train = "data/attribute_data.txt"
# f_test = "data/test_attr2.txt"
f_w2v = "../embedding/embedding_all_merge_300.txt"
f_dict = "../dataset/attribute.json"
print(f_w2v)
raw_texts, raw_labels = load_attr_data(filename=f_train)
W, word2index = load_w2v(f_w2v)
attr_list, attr_dict = parse_json(f_dict)
kf = 0
_, test_index = kfold_split(len(raw_texts), args.folds)[2]
test_texts, test_labels = [raw_texts[i] for i in test_index
], [raw_labels[i] for i in test_index]
test_data = Data((test_texts, test_labels), word2index, attr_dict, args)
test_predict = train.predict(model.classifier, test_data, args)
pred_acc_t = score(test_predict, test_data.labels)
print(pred_acc_t)
def main(_):
word_id_mapping_o, w2v_o = load_w2v(FLAGS.embedding_file,
FLAGS.embedding_dim, True)
# word_id_mapping_o, w2v_o = load_word_embedding(FLAGS.word_id_file, FLAGS.embedding_file, FLAGS.embedding_dim, True)
word_embedding_o = tf.constant(w2v_o, dtype=tf.float32)
# word_id_mapping_r, w2v_r = load_w2v(FLAGS.embedding_file_r, FLAGS.embedding_dim, True)
# word_id_mapping_r, w2v_r = load_word_embedding(FLAGS.word_id_file, FLAGS.embedding_file_r, FLAGS.embedding_dim, True)
word_id_mapping_r = word_id_mapping_o
word_embedding_r = tf.constant(w2v_o, dtype=tf.float32)
with tf.name_scope('inputs'):
keep_prob1 = tf.placeholder(tf.float32)
keep_prob2 = tf.placeholder(tf.float32)
x_o = tf.placeholder(tf.int32,
[None, FLAGS.max_doc_len, FLAGS.max_sentence_len])
x_r = tf.placeholder(tf.int32,
[None, FLAGS.max_doc_len, FLAGS.max_sentence_len])
sen_len_o = tf.placeholder(tf.int32, [None, FLAGS.max_doc_len])
sen_len_r = tf.placeholder(tf.int32, [None, FLAGS.max_doc_len])
doc_len_o = tf.placeholder(tf.int32, None)
doc_len_r = tf.placeholder(tf.int32, None)
y = tf.placeholder(tf.float32, [None, FLAGS.n_class])
with tf.device('/gpu:0'):
inputs_o = tf.nn.embedding_lookup(word_embedding_o, x_o)
inputs_o = tf.reshape(
inputs_o, [-1, FLAGS.max_sentence_len, FLAGS.embedding_dim])
if FLAGS.method == 'ATT':
h_o = hn_att(inputs_o, sen_len_o, doc_len_o, keep_prob1,
keep_prob2, 'o')
else:
h_o = hn(inputs_o, sen_len_o, doc_len_o, keep_prob1, keep_prob2,
'o')
prob_o = softmax_layer(h_o, 2 * FLAGS.n_hidden, FLAGS.random_base,
keep_prob2, FLAGS.l2_reg, FLAGS.n_class, 'o')
with tf.device('/gpu:1'):
inputs_r = tf.nn.embedding_lookup(word_embedding_r, x_r)
inputs_r = tf.reshape(
inputs_r, [-1, FLAGS.max_sentence_len, FLAGS.embedding_dim])
if FLAGS.method == 'ATT':
h_r = hn_att(inputs_r, sen_len_r, doc_len_r, keep_prob1,
keep_prob2, 'r')
else:
h_r = hn(inputs_r, sen_len_r, doc_len_r, keep_prob1, keep_prob2,
'r')
prob_r = softmax_layer(h_r, 2 * FLAGS.n_hidden, FLAGS.random_base,
keep_prob2, FLAGS.l2_reg, FLAGS.n_class, 'r')
with tf.name_scope('loss'):
r_y = tf.reverse(y, [True])
reg_loss = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)
# loss = - tf.reduce_mean(y * tf.log(prob_o)) - tf.reduce_mean(r_y * tf.log(prob_r)) + sum(reg_loss)
# prob = FLAGS.alpha * prob_o + (1.0 - FLAGS.alpha) * tf.reverse(prob_r, [False, True])
loss_o = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(logits=prob_o, labels=y))
loss_r = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(logits=prob_r, labels=y))
loss = loss_o + loss_r + tf.add_n(reg_loss)
prob = FLAGS.alpha * prob_o + (1.0 - FLAGS.alpha) * tf.reverse(
prob_r, [True])
all_vars = [var for var in tf.global_variables()]
with tf.name_scope('train'):
global_step = tf.Variable(0, name='global_step', trainable=False)
optimizer = tf.train.AdamOptimizer(learning_rate=FLAGS.learning_rate)
grads, global_norm = tf.clip_by_global_norm(
tf.gradients(loss, all_vars), 5.0)
train_op = optimizer.apply_gradients(zip(grads, all_vars),
name='train_op',
global_step=global_step)
with tf.name_scope('predict'):
cor_pred = tf.equal(tf.argmax(prob, 1), tf.argmax(y, 1))
acc_prob = tf.reduce_mean(tf.cast(cor_pred, tf.float32))
acc_num = tf.reduce_sum(tf.cast(cor_pred, tf.int32))
true_y = tf.argmax(y, 1)
pred_y = tf.argmax(prob, 1)
title = '-d1-{}d2-{}b-{}r-{}l2-{}sen-{}dim-{}h-{}c-{}'.format(
FLAGS.keep_prob1, FLAGS.keep_prob2, FLAGS.batch_size,
FLAGS.learning_rate, FLAGS.l2_reg, FLAGS.max_sentence_len,
FLAGS.embedding_dim, FLAGS.n_hidden, FLAGS.n_class)
conf = tf.ConfigProto(allow_soft_placement=True)
with tf.Session(config=conf) as sess:
import time
timestamp = str(int(time.time()))
_dir = 'summary/' + str(timestamp) + '_' + title
test_loss = tf.placeholder(tf.float32)
test_acc = tf.placeholder(tf.float32)
train_summary_op, test_summary_op, validate_summary_op, train_summary_writer, test_summary_writer, \
validate_summary_writer = summary_func(loss, acc_prob, test_loss, test_acc, _dir, title, sess)
save_dir = 'temp_model/' + str(timestamp) + '_' + title + '/'
saver = saver_func(save_dir)
init = tf.global_variables_initializer()
sess.run(init)
# saver.restore(sess, '/-')
tr_x, tr_y, tr_sen_len, tr_doc_len = load_inputs_document(
FLAGS.train_file, word_id_mapping_o, FLAGS.max_sentence_len,
FLAGS.max_doc_len)
te_x, te_y, te_sen_len, te_doc_len = load_inputs_document(
FLAGS.test_file, word_id_mapping_o, FLAGS.max_sentence_len,
FLAGS.max_doc_len)
tr_x_r, tr_y_r, tr_sen_len_r, tr_doc_len_r = load_inputs_document(
FLAGS.train_file_r, word_id_mapping_r, FLAGS.max_sentence_len,
FLAGS.max_doc_len)
te_x_r, te_y_r, te_sen_len_r, te_doc_len_r = load_inputs_document(
FLAGS.test_file_r, word_id_mapping_r, FLAGS.max_sentence_len,
FLAGS.max_doc_len)
# v_x, v_y, v_sen_len, v_doc_len = load_inputs_document(
# FLAGS.validate_file,
# word_id_mapping,
# FLAGS.max_sentence_len,
# FLAGS.max_doc_len
# )
# v_x, v_y, v_sen_len, v_doc_len = load_inputs_document(
# FLAGS.validate_file,
# word_id_mapping,
# FLAGS.max_sentence_len,
# FLAGS.max_doc_len
# )
def get_batch_data(xo,
slo,
dlo,
xr,
slr,
dlr,
yy,
batch_size,
kp1,
kp2,
is_shuffle=True):
for index in batch_index(len(yy), batch_size, 1, is_shuffle):
feed_dict = {
x_o: xo[index],
x_r: xr[index],
y: yy[index],
sen_len_o: slo[index],
sen_len_r: slr[index],
doc_len_o: dlo[index],
doc_len_r: dlr[index],
keep_prob1: kp1,
keep_prob2: kp2,
}
yield feed_dict, len(index)
max_acc, max_prob, step = 0., None, None
max_ty, max_py = None, None
for i in xrange(FLAGS.n_iter):
for train, _ in get_batch_data(tr_x, tr_sen_len, tr_doc_len,
tr_x_r, tr_sen_len_r, tr_doc_len_r,
tr_y, FLAGS.batch_size,
FLAGS.keep_prob1, FLAGS.keep_prob2):
_, step, summary = sess.run(
[train_op, global_step, train_summary_op], feed_dict=train)
train_summary_writer.add_summary(summary, step)
# embed_update = tf.assign(word_embedding, tf.concat(0, [tf.zeros([1, FLAGS.embedding_dim]), word_embedding[1:]]))
# sess.run(embed_update)
acc, cost, cnt = 0., 0., 0
p, ty, py = [], [], []
for test, num in get_batch_data(te_x, te_sen_len, te_doc_len,
te_x_r, te_sen_len_r, te_doc_len_r,
te_y, 2000, 1.0, 1.0, False):
_loss, _acc, _p, _ty, _py = sess.run(
[loss, acc_num, prob, true_y, pred_y], feed_dict=test)
p += list(_p)
ty += list(_ty)
py += list(_py)
acc += _acc
cost += _loss * num
cnt += num
print 'all samples={}, correct prediction={}'.format(cnt, acc)
acc = acc / cnt
cost = cost / cnt
print 'Iter {}: mini-batch loss={:.6f}, test acc={:.6f}'.format(
i, cost, acc)
summary = sess.run(test_summary_op,
feed_dict={
test_loss: cost,
test_acc: acc
})
test_summary_writer.add_summary(summary, step)
if acc > max_acc:
max_acc = acc
max_prob = p
max_ty = ty
max_py = py
# saver.save(sess, save_dir, global_step=step)
print 'P:', precision_score(max_ty, max_py, average=None)
print 'R:', recall_score(max_ty, max_py, average=None)
print 'F:', f1_score(max_ty, max_py, average=None)
fp = open(FLAGS.prob_file, 'w')
for item in max_prob:
fp.write(' '.join([str(it) for it in item]) + '\n')
print 'Optimization Finished! Max acc={}'.format(max_acc)
print 'Learning_rate={}, iter_num={}, batch_size={}, hidden_num={}, l2={}'.format(
FLAGS.learning_rate, FLAGS.n_iter, FLAGS.batch_size,
FLAGS.n_hidden, FLAGS.l2_reg)
def main(_):
word_id_mapping, w2v = load_w2v(FLAGS.embedding_file_path,
FLAGS.embedding_dim, True)
word_embedding = tf.constant(w2v, dtype=tf.float32)
with tf.name_scope('inputs'):
keep_prob1 = tf.placeholder(tf.float32)
keep_prob2 = tf.placeholder(tf.float32)
x_l = tf.placeholder(tf.int32, [None, FLAGS.max_sentence_len])
x_r = tf.placeholder(tf.int32, [None, FLAGS.max_sentence_len])
len_l = tf.placeholder(tf.int32, [None])
len_r = tf.placeholder(tf.int32, [None])
y = tf.placeholder(tf.float32, [None, FLAGS.n_class])
inputs_l = tf.nn.embedding_lookup(word_embedding, x_l)
inputs_r = tf.nn.embedding_lookup(word_embedding, x_r)
prob = ian(inputs_l, len_l, inputs_r, len_r, keep_prob1, keep_prob2)
reg_loss = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)
loss = -tf.reduce_mean(y * tf.log(prob)) + sum(reg_loss)
acc_num, acc_prob = acc_func(y, prob)
global_step = tf.Variable(0, name='tr_global_step', trainable=False)
optimizer = tf.train.MomentumOptimizer(learning_rate=FLAGS.learning_rate,
momentum=0.5).minimize(
loss, global_step=global_step)
optimizer = tf.train.AdamOptimizer(
learning_rate=FLAGS.learning_rate).minimize(loss,
global_step=global_step)
# optimizer = train_func(loss, FLAGS.learning_rate, global_step)
true_y = tf.argmax(y, 1)
pred_y = tf.argmax(prob, 1)
title = '-d1-{}d2-{}b-{}r-{}l2-{}sen-{}dim-{}h-{}c-{}'.format(
FLAGS.keep_prob1, FLAGS.keep_prob2, FLAGS.batch_size,
FLAGS.learning_rate, FLAGS.l2_reg, FLAGS.max_sentence_len,
FLAGS.embedding_dim, FLAGS.n_hidden, FLAGS.n_class)
conf = tf.ConfigProto(allow_soft_placement=True)
with tf.Session(config=conf) as sess:
import time
timestamp = str(int(time.time()))
_dir = 'summary/' + str(timestamp) + '_' + title
test_loss = tf.placeholder(tf.float32)
test_acc = tf.placeholder(tf.float32)
train_summary_op, test_summary_op, validate_summary_op, train_summary_writer, test_summary_writer, \
validate_summary_writer = summary_func(loss, acc_prob, test_loss, test_acc, _dir, title, sess)
save_dir = 'temp_model/' + str(timestamp) + '_' + title + '/'
saver = saver_func(save_dir)
init = tf.initialize_all_variables()
sess.run(init)
# saver.restore(sess, '/-')
tr_x1, tr_x2, tr_len1, tr_len2, tr_y = load_sentence(
FLAGS.train_file_path, word_id_mapping, FLAGS.max_sentence_len)
te_x1, te_x2, te_len1, te_len2, te_y = load_sentence(
FLAGS.test_file_path, word_id_mapping, FLAGS.max_sentence_len)
def get_batch_data(x1,
x2,
len1,
len2,
yy,
batch_size,
kp1,
kp2,
is_shuffle=True):
for index in batch_index(len(yy), batch_size, 1, is_shuffle):
feed_dict = {
x_l: x1[index],
x_r: x2[index],
y: yy[index],
len_l: len1[index],
len_r: len2[index],
keep_prob1: kp1,
keep_prob2: kp2,
}
yield feed_dict, len(index)
max_acc, max_prob, step = 0., None, None
max_ty, max_py = None, None
for i in xrange(FLAGS.n_iter):
for train, _ in get_batch_data(tr_x1, tr_x2, tr_len1, tr_len2,
tr_y, FLAGS.batch_size,
FLAGS.keep_prob1, FLAGS.keep_prob2):
_, step, summary = sess.run(
[optimizer, global_step, train_summary_op],
feed_dict=train)
train_summary_writer.add_summary(summary, step)
# embed_update = tf.assign(word_embedding, tf.concat([tf.zeros([1, FLAGS.embedding_dim]), word_embedding[1:]], 0))
# sess.run(embed_update)
acc, cost, cnt = 0., 0., 0
p, ty, py = [], [], []
for test, num in get_batch_data(te_x1, te_x2, te_len1, te_len2,
te_y, 2000, 1.0, 1.0, False):
_loss, _acc, _p, _ty, _py = sess.run(
[loss, acc_num, prob, true_y, pred_y], feed_dict=test)
p += list(_p)
ty += list(_ty)
py += list(_py)
acc += _acc
cost += _loss * num
cnt += num
print 'all samples={}, correct prediction={}'.format(cnt, acc)
acc = acc / cnt
cost = cost / cnt
print 'Iter {}: mini-batch loss={:.6f}, test acc={:.6f}'.format(
i, cost, acc)
summary = sess.run(test_summary_op,
feed_dict={
test_loss: cost,
test_acc: acc
})
test_summary_writer.add_summary(summary, step)
if acc > max_acc:
max_acc = acc
max_prob = p
max_ty = ty
max_py = py
saver.save(sess, save_dir, global_step=step)
print 'P:', precision_score(max_ty, max_py, average=None)
print 'R:', recall_score(max_ty, max_py, average=None)
print 'F:', f1_score(max_ty, max_py, average=None)
fp = open(FLAGS.prob_file, 'w')
for item in max_prob:
fp.write(' '.join([str(it) for it in item]) + '\n')
print 'Optimization Finished! Max acc={}'.format(max_acc)
print 'Learning_rate={}, iter_num={}, batch_size={}, hidden_num={}, l2={}'.format(
FLAGS.learning_rate, FLAGS.n_iter, FLAGS.batch_size,
FLAGS.n_hidden, FLAGS.l2_reg)
def main(_):
word_id_mapping_o, w2v_o = load_w2v(FLAGS.embedding_file_o,
FLAGS.embedding_dim, True)
word_embedding_o = tf.constant(w2v_o, dtype=tf.float32)
word_id_mapping_r, w2v_r = load_w2v(FLAGS.embedding_file_r,
FLAGS.embedding_dim, True)
word_embedding_r = tf.constant(w2v_r, dtype=tf.float32)
with tf.name_scope('inputs'):
keep_prob1 = tf.placeholder(tf.float32)
keep_prob2 = tf.placeholder(tf.float32)
x_o = tf.placeholder(tf.int32, [None, FLAGS.max_sentence_len])
x_r = tf.placeholder(tf.int32, [None, FLAGS.max_sentence_len])
len_o = tf.placeholder(tf.int32, [None])
len_r = tf.placeholder(tf.int32, [None])
y = tf.placeholder(tf.float32, [None, FLAGS.n_class])
with tf.device('/gpu:0'):
inputs_o = tf.nn.embedding_lookup(word_embedding_o, x_o)
inputs_o = tf.reshape(
inputs_o, [-1, FLAGS.max_sentence_len, FLAGS.embedding_dim])
if FLAGS.method == 'ATT':
prob_o = bi_rnn_att(inputs_o, len_o, keep_prob1, keep_prob2, 'o')
else:
prob_o = bi_rnn(inputs_o, len_o, keep_prob1, keep_prob2, 'o')
with tf.device('/gpu:1'):
inputs_r = tf.nn.embedding_lookup(word_embedding_r, x_r)
inputs_r = tf.reshape(
inputs_r, [-1, FLAGS.max_sentence_len, FLAGS.embedding_dim])
if FLAGS.method == 'ATT':
prob_r = bi_rnn_att(inputs_r, len_r, keep_prob1, keep_prob2, 'r')
else:
prob_r = bi_rnn(inputs_r, len_r, keep_prob1, keep_prob2, 'r')
r_y = tf.reverse(y, [False, True])
reg_loss = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)
loss = -tf.reduce_mean(y * tf.log(prob_o)) - tf.reduce_mean(
r_y * tf.log(prob_r)) + sum(reg_loss)
prob = FLAGS.alpha * prob_o + (1.0 - FLAGS.alpha) * tf.reverse(
prob_r, [False, True])
acc_num, acc_prob = acc_func(y, prob)
global_step = tf.Variable(0, name='tr_global_step', trainable=False)
optimizer = train_func(loss, FLAGS.learning_rate, global_step)
title = '-d1-{}d2-{}b-{}r-{}l2-{}sen-{}dim-{}h-{}c-{}'.format(
FLAGS.keep_prob1, FLAGS.keep_prob2, FLAGS.batch_size,
FLAGS.learning_rate, FLAGS.l2_reg, FLAGS.max_sentence_len,
FLAGS.embedding_dim, FLAGS.n_hidden, FLAGS.n_class)
conf = tf.ConfigProto(allow_soft_placement=True)
with tf.Session(config=conf) as sess:
import time
timestamp = str(int(time.time()))
_dir = 'summary/' + str(timestamp) + '_' + title
_dir = 'summary/' + title
test_loss = tf.placeholder(tf.float32)
test_acc = tf.placeholder(tf.float32)
train_summary_op, test_summary_op, validate_summary_op, train_summary_writer, test_summary_writer, \
validate_summary_writer = summary_func(loss, acc_prob, test_loss, test_acc, _dir, title, sess)
save_dir = 'temp_model/' + str(timestamp) + '_' + title + '/'
saver = saver_func(save_dir)
init = tf.global_variables_initializer()
sess.run(init)
# saver.restore(sess, '/-')
tr_x, tr_sen_len, tr_y = load_inputs_twitter(FLAGS.train_file,
word_id_mapping_o,
FLAGS.max_sentence_len)
te_x, te_sen_len, te_y = load_inputs_twitter(FLAGS.test_file,
word_id_mapping_o,
FLAGS.max_sentence_len)
tr_x_r, tr_sen_len_r, tr_y_r = load_inputs_twitter(
FLAGS.train_file_r, word_id_mapping_r, FLAGS.max_sentence_len)
te_x_r, te_sen_len_r, te_y_r = load_inputs_twitter(
FLAGS.test_file_r, word_id_mapping_r, FLAGS.max_sentence_len)
def get_batch_data(xo,
slo,
xr,
slr,
yy,
batch_size,
kp1,
kp2,
is_shuffle=True):
for index in batch_index(len(yy), batch_size, 1, is_shuffle):
feed_dict = {
x_o: xo[index],
x_r: xr[index],
y: yy[index],
len_o: slo[index],
len_r: slr[index],
keep_prob1: kp1,
keep_prob2: kp2,
}
yield feed_dict, len(index)
max_acc, max_prob, step = 0., None, None
for i in xrange(FLAGS.n_iter):
for train, _ in get_batch_data(tr_x, tr_sen_len, tr_x_r,
tr_sen_len_r, tr_y,
FLAGS.batch_size, FLAGS.keep_prob1,
FLAGS.keep_prob2):
_, step, summary = sess.run(
[optimizer, global_step, train_summary_op],
feed_dict=train)
train_summary_writer.add_summary(summary, step)
saver.save(sess, save_dir, global_step=step)
acc, cost, cnt = 0., 0., 0
p = []
for test, num in get_batch_data(te_x, te_sen_len, te_x_r,
te_sen_len_r, te_y, 2000, 1.0, 1.0,
False):
_loss, _acc, _p = sess.run([loss, acc_num, prob],
feed_dict=test)
p += list(_p)
acc += _acc
cost += _loss * num
cnt += num
print 'all samples={}, correct prediction={}'.format(cnt, acc)
acc = acc / cnt
cost = cost / cnt
print 'Iter {}: mini-batch loss={:.6f}, test acc={:.6f}'.format(
i, cost, acc)
summary = sess.run(test_summary_op,
feed_dict={
test_loss: cost,
test_acc: acc
})
test_summary_writer.add_summary(summary, step)
if acc > max_acc:
max_acc = acc
max_prob = p
fp = open(FLAGS.prob_file, 'w')
for item in max_prob:
fp.write(' '.join([str(it) for it in item]) + '\n')
print 'Optimization Finished! Max acc={}'.format(max_acc)
print 'Learning_rate={}, iter_num={}, batch_size={}, hidden_num={}, l2={}'.format(
FLAGS.learning_rate, FLAGS.n_iter, FLAGS.batch_size,
FLAGS.n_hidden, FLAGS.l2_reg)
