def run(self, sess, train_data_l, train_data_u, test_data, n_iter, keep_rate, save_dir, batch_size, alpha, FLAGS):
self.init_global_step()
with tf.name_scope('labeled'):
with tf.variable_scope('classifier'):
self.classifier_xa_l = self.classifier.create_placeholders('xa')
self.classifier_y_l = self.classifier.create_placeholders('y')
self.classifier_hyper_l = self.classifier.create_placeholders('hyper')
logits_l = self.classifier.forward(self.classifier_xa_l, self.classifier_hyper_l)
classifier_loss_l, classifier_acc_l, pri_loss_l = self.classifier.get_loss(logits_l, self.classifier_y_l, self.pri_prob_y)
with tf.variable_scope('encoder'):
self.encoder_xa_l = self.encoder.create_placeholders('xa')
self.encoder_y_l = self.encoder.create_placeholders('y')
self.encoder_hyper_l = self.encoder.create_placeholders('hyper')
z_pst, z_pri, encoder_loss_l = self.encoder.forward(self.encoder_xa_l, self.encoder_y_l, self.encoder_hyper_l)
with tf.variable_scope('decoder'):
self.decoder_xa_l = self.decoder.create_placeholders('xa') #x is included since x is generated sequentially
self.decoder_y_l = self.decoder.create_placeholders('y')
self.decoder_hyper_l = self.decoder.create_placeholders('hyper')
decoder_loss_l, ppl_fw_l, ppl_bw_l, ppl_l = self.decoder.forward(self.decoder_xa_l, self.decoder_y_l, z_pst, self.decoder_hyper_l)
elbo_l = encoder_loss_l * self.klw + decoder_loss_l - pri_loss_l
self.loss_l = elbo_l
self.loss_c = classifier_loss_l
with tf.name_scope('unlabeled'):
with tf.variable_scope('classifier', reuse=True):
self.classifier_xa_u = self.classifier.create_placeholders('xa')
self.classifier_hyper_u = self.classifier.create_placeholders('hyper')
logits_u = self.classifier.forward(self.classifier_xa_u, self.classifier_hyper_u)
predict_u = tf.nn.softmax(logits_u)
classifier_entropy_u = tf.losses.softmax_cross_entropy(predict_u, predict_u)
encoder_loss_u, decoder_loss_u = [], []
elbo_u = []
self.encoder_xa_u = self.encoder.create_placeholders('xa')
self.encoder_hyper_u = self.encoder.create_placeholders('hyper')
self.decoder_xa_u = self.decoder.create_placeholders('xa')
self.decoder_hyper_u = self.decoder.create_placeholders('hyper')
batch_size = tf.shape(list(self.encoder_xa_u.values())[0])[0]
for idx in range(self.n_class):
with tf.variable_scope('encoder', reuse=True):
_label = tf.gather(tf.eye(self.n_class), idx)
_label = tf.tile(_label[None, :], [batch_size, 1])
_z_pst, _, _encoder_loss = self.encoder.forward(self.encoder_xa_u, {'y':_label}, self.encoder_hyper_u)
encoder_loss_u.append(_encoder_loss * self.klw)
_pri_loss_u = tf.log(tf.gather(self.pri_prob_y, idx))
with tf.variable_scope('decoder', reuse=True):
_decoder_loss, _, _, _ = self.decoder.forward(self.decoder_xa_u, {'y':_label}, _z_pst, self.decoder_hyper_u)
decoder_loss_u.append(_decoder_loss)
_elbo_u = _encoder_loss * self.klw + _decoder_loss# - _pri_loss_u
elbo_u.append(_elbo_u)
self.loss_u = tf.add_n([elbo_u[idx] * predict_u[:, idx] for idx in range(self.n_class)]) + classifier_entropy_u
self.loss = tf.reduce_mean(self.loss_l + classifier_loss_l * alpha + self.loss_u)
#self.loss = tf.reduce_mean(classifier_loss_l)
decoder_loss_l = tf.reduce_mean(decoder_loss_l)
with tf.name_scope('train'):
optimizer = tf.train.AdamOptimizer(learning_rate=self.learning_rate).minimize(self.loss, global_step=self.global_step)
#optimizer = self.training_op(self.loss, tf.trainable_variables(), self.grad_clip, 20, self.learning_rate)
summary_kl = tf.summary.scalar('kl', tf.reduce_mean(encoder_loss_l))
summary_loss = tf.summary.scalar('loss', self.loss)
summary_loss_l = tf.summary.scalar('loss_l', tf.reduce_mean(self.loss_l))
summary_loss_u = tf.summary.scalar('loss_u', tf.reduce_mean(self.loss_u))
summary_acc = tf.summary.scalar('acc', classifier_acc_l)
summary_ppl_fw = tf.summary.scalar('ppl_fw', ppl_fw_l)
summary_ppl_bw = tf.summary.scalar('ppl_bw', ppl_bw_l)
summary_ppl = tf.summary.scalar('ppl', ppl_l)
train_summary_op = tf.summary.merge_all()
test_acc = tf.placeholder(tf.float32, [])
test_ppl = tf.placeholder(tf.float32, [])
summary_acc_test = tf.summary.scalar('test_acc', test_acc)
summary_ppl_test = tf.summary.scalar('test_ppl', test_ppl)
test_summary_op = tf.summary.merge([summary_acc_test, summary_ppl_test])
logger = ExpLogger('semi_tabsa', save_dir)
logger.write_args(FLAGS)
logger.write_variables(tf.trainable_variables())
logger.file_copy(['*.py', 'encoder/*.py', 'decoder/*.py', 'classifier/*.py'])
train_summary_writer = tf.summary.FileWriter(save_dir + '/train', sess.graph)
test_summary_writer = tf.summary.FileWriter(save_dir + '/test', sess.graph)
validate_summary_writer = tf.summary.FileWriter(save_dir + '/validate', sess.graph)
sess.run(tf.global_variables_initializer())
def get_batch(dataset):
""" to get batch from an iterator, whenever the ending is reached. """
while True:
try:
batch = dataset.next()
break
except:
pass
return batch
def get_feed_dict_help(plhs, data_dict, keep_rate, is_training):
plh_dict = {}
for plh in plhs: plh_dict.update(plh)
data_dict.update({'keep_rate': keep_rate})
data_dict.update({'is_training': is_training})
feed_dict = self.get_feed_dict(plh_dict, data_dict)
return feed_dict
max_acc = 0.
for i in range(n_iter):
#for train, _ in self.get_batch_data(train_data, keep_rate):
for samples, in train_data_l:
feed_dict_clf_l = get_feed_dict_help(plhs=[self.classifier_xa_l, self.classifier_y_l, self.classifier_hyper_l],
data_dict=self.classifier.prepare_data(samples),
keep_rate=keep_rate,
is_training=True)
feed_dict_enc_l = get_feed_dict_help(plhs=[self.encoder_xa_l, self.encoder_y_l, self.encoder_hyper_l],
data_dict=self.encoder.prepare_data(samples),
keep_rate=keep_rate,
is_training=True)
feed_dict_dec_l = get_feed_dict_help(plhs=[self.decoder_xa_l, self.decoder_y_l, self.decoder_hyper_l],
data_dict=self.decoder.prepare_data(samples),
keep_rate=keep_rate,
is_training=True)
samples, = get_batch(train_data_u)
feed_dict_clf_u = get_feed_dict_help(plhs=[self.classifier_xa_u, self.classifier_hyper_u],
data_dict=self.classifier.prepare_data(samples),
keep_rate=keep_rate,
is_training=True)
feed_dict_enc_u = get_feed_dict_help(plhs=[self.encoder_xa_u, self.encoder_hyper_u],
data_dict=self.encoder.prepare_data(samples),
keep_rate=keep_rate,
is_training=True)
feed_dict_dec_u = get_feed_dict_help(plhs=[self.decoder_xa_u, self.decoder_hyper_u],
data_dict=self.decoder.prepare_data(samples),
keep_rate=keep_rate,
is_training=True)
feed_dict = {}
feed_dict.update(feed_dict_clf_l)
feed_dict.update(feed_dict_enc_l)
feed_dict.update(feed_dict_dec_l)
feed_dict.update(feed_dict_clf_u)
feed_dict.update(feed_dict_enc_u)
feed_dict.update(feed_dict_dec_u)
feed_dict.update({self.klw: 0.0001})
_, _acc, _loss, _ppl, _step, summary = sess.run([optimizer, classifier_acc_l, decoder_loss_l, ppl_l, self.global_step, train_summary_op], feed_dict=feed_dict)
#_, _acc, _step, summary = sess.run([optimizer, classifier_acc_l, self.global_step, train_summary_op], feed_dict=feed_dict)
train_summary_writer.add_summary(summary, _step)
#if np.random.rand() < 1/4:
# print(_acc, _loss, _ppl, _step)
acc, ppl, loss, cnt = 0., 0., 0., 0
for samples, in test_data:
feed_dict_clf_l = get_feed_dict_help(plhs=[self.classifier_xa_l, self.classifier_y_l, self.classifier_hyper_l],
data_dict=self.classifier.prepare_data(samples),
keep_rate=1.0,
is_training=False)
feed_dict_enc_l = get_feed_dict_help(plhs=[self.encoder_xa_l, self.encoder_y_l, self.encoder_hyper_l],
data_dict=self.encoder.prepare_data(samples),
keep_rate=1.0,
is_training=False)
feed_dict_dec_l = get_feed_dict_help(plhs=[self.decoder_xa_l, self.decoder_y_l, self.decoder_hyper_l],
data_dict=self.decoder.prepare_data(samples),
keep_rate=1.0,
is_training=False)
feed_dict = {}
feed_dict.update(feed_dict_clf_l)
feed_dict.update(feed_dict_enc_l)
feed_dict.update(feed_dict_dec_l)
feed_dict.update({self.klw: 0})
_acc, _loss, _ppl, _step = sess.run([classifier_acc_l, decoder_loss_l, ppl_l, self.global_step], feed_dict=feed_dict)
acc += _acc * len(samples)
ppl += _ppl * len(samples)
loss += _loss * len(samples)
cnt += len(samples)
#print(cnt)
#print(acc)
summary, _step = sess.run([test_summary_op, self.global_step], feed_dict={test_acc: acc/cnt, test_ppl: ppl/cnt})
test_summary_writer.add_summary(summary, _step)
logger.info('Iter {}: mini-batch loss={:.6f}, test acc={:.6f}'.format(_step, loss / cnt, acc / cnt))
#print(save_dir)
_dir="unlabel10k"
if acc / cnt > max_acc:
max_acc = acc / cnt
logger.info('Optimization Finished! Max acc={}'.format(max_acc))
logger.info('Learning_rate={}, iter_num={}, hidden_num={}, l2={}'.format(
self.learning_rate,
n_iter,
self.n_hidden,
self.l2_reg
))
def selftraining(sess, classifier, label_data, unlabel_data, test_data, FLAGS):
xa_inputs = classifier.create_placeholders('xa')
hyper_inputs = classifier.create_placeholders('hyper')
y_inputs = classifier.create_placeholders('y')
logits = classifier.forward(xa_inputs, hyper_inputs)
loss, acc, _ = classifier.get_loss(logits, y_inputs,
[0.0] * classifier.n_class)
pred = tf.argmax(logits, axis=1)
prob = tf.reduce_max(tf.nn.softmax(logits), axis=1)
import time, datetime
timestamp = str(int(time.time()))
timestamp = datetime.datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
save_dir = FLAGS.save_dir + '/selftraining/' + str(
timestamp) + '/' + __file__.split('.')[0]
print(save_dir)
logger = ExpLogger('semi_tabsa', save_dir)
logger.write_args(vars(FLAGS)['__flags'])
logger.write_variables(tf.trainable_variables())
logger.file_copy(
['*.py', 'encoder/*.py', 'decoder/*.py', 'classifier/*.py'])
def get_feed_dict_help(classifier, plhs, data_dict, keep_rate,
is_training):
plh_dict = {}
for plh in plhs:
plh_dict.update(plh)
data_dict.update({'keep_rate': keep_rate})
data_dict.update({'is_training': is_training})
feed_dict = classifier.get_feed_dict(plh_dict, data_dict)
return feed_dict
with tf.name_scope('train'):
loss = tf.reduce_mean(loss)
optimizer = classifier.training_op(loss,
tf.trainable_variables(),
FLAGS.grad_clip,
20,
FLAGS.learning_rate,
grads=None,
opt='Adam')
NUM_SELECT = 1000
NUM_ITER = 500
best_acc_in_rounds, best_f1_in_rounds = [], []
while len(unlabel_data):
tf.global_variables_initializer().run()
test_it = BatchIterator(len(test_data),
FLAGS.batch_size, [test_data],
testing=True)
print(len(unlabel_data))
selected = []
new_unlabel = []
it_cnt = 0
best_acc, best_f1 = 0, 0
while True:
train_it = BatchIterator(len(label_data),
FLAGS.batch_size, [label_data],
testing=False)
unlabel_it = BatchIterator(len(unlabel_data),
FLAGS.batch_size, [unlabel_data],
testing=True)
for samples, in train_it:
it_cnt += 1
if it_cnt > NUM_ITER:
break
feed_dict = get_feed_dict_help(
classifier,
plhs=[xa_inputs, y_inputs, hyper_inputs],
data_dict=classifier.prepare_data(samples),
keep_rate=FLAGS.keep_rate,
is_training=True)
_, _loss, _acc, _step = sess.run(
[optimizer, loss, acc, classifier.global_step],
feed_dict=feed_dict)
#print('Train: step {}, acc {}, loss {}'.format(it_cnt, _acc, _loss))
### proc test
test_acc, cnt = 0, 0
y_true = []
y_pred = []
for samples, in test_it:
data_dict = classifier.prepare_data(samples)
feed_dict = get_feed_dict_help(
classifier,
plhs=[xa_inputs, y_inputs, hyper_inputs],
data_dict=data_dict,
keep_rate=1.0,
is_training=False)
num = len(samples)
_acc, _loss, _pred, _step = sess.run(
[acc, loss, pred, classifier.global_step],
feed_dict=feed_dict)
y_pred.extend(list(_pred))
y_true.extend(list(np.argmax(data_dict['y'], 1)))
test_acc += _acc * num
cnt += num
test_acc = test_acc / cnt
test_f1 = f1_score(y_true, y_pred, average='macro')
logger.info(
'Test: step {}, test acc={:.6f}, test f1={:.6f}'.format(
it_cnt, test_acc, test_f1))
best_f1 = max(best_f1, test_f1)
### proc unlabel
if best_acc < test_acc:
best_acc = test_acc
_unlabel = []
_preds = []
_probs = []
y_dict = {0: 'positive', 1: 'negative', 2: 'neutral'}
for samples, in unlabel_it:
feed_dict = get_feed_dict_help(
classifier,
plhs=[xa_inputs, hyper_inputs],
data_dict=classifier.prepare_data(samples),
keep_rate=1.0,
is_training=False)
_pred, _prob = sess.run([pred, prob],
feed_dict=feed_dict)
_unlabel.extend(samples)
_preds.extend(list(_pred))
_probs.extend(list(_prob))
top_k_id = np.argsort(_probs)[::-1][:NUM_SELECT]
remain_id = np.argsort(_probs)[::-1][NUM_SELECT:]
selected = [_unlabel[idx] for idx in top_k_id]
preds = [_preds[idx] for idx in top_k_id]
for idx, sample in enumerate(selected):
sample['polarity'] = y_dict[preds[idx]]
new_unlabel = [_unlabel[idx] for idx in remain_id]
if it_cnt > NUM_ITER:
best_acc_in_rounds.append(best_acc)
best_f1_in_rounds.append(best_f1)
logger.info(str(best_acc_in_rounds) + str(best_f1_in_rounds))
break
label_data.extend(selected)
unlabel_data = new_unlabel
#print(max(best_acc_in_rounds), max(best_f1_in_rounds))
logger.info(str(best_acc_in_rounds) + str(best_f1_in_rounds))
def run(self, sess, train_data_l, train_data_u, test_data, n_iter, keep_rate, save_dir, batch_size, alpha, FLAGS):
self.init_global_step()
with tf.name_scope('labeled'):
with tf.variable_scope('classifier'):
self.classifier_xa_l = self.classifier.create_placeholders('xa')
self.classifier_y_l = self.classifier.create_placeholders('y')
self.classifier_hyper_l = self.classifier.create_placeholders('hyper')
logits_l = self.classifier.forward(self.classifier_xa_l, self.classifier_hyper_l)
classifier_loss_l, classifier_acc_l, pri_loss_l = self.classifier.get_loss(logits_l, self.classifier_y_l, self.pri_prob_y)
pred_l = tf.argmax(logits_l, axis=1)
with tf.variable_scope('encoder'):
self.encoder_xa_l = self.encoder.create_placeholders('xa')
self.encoder_y_l = self.encoder.create_placeholders('y')
self.encoder_hyper_l = self.encoder.create_placeholders('hyper')
z_pst, z_pri, encoder_loss_l = self.encoder.forward(self.encoder_xa_l, self.encoder_y_l, self.encoder_hyper_l)
with tf.variable_scope('decoder'):
self.decoder_xa_l = self.decoder.create_placeholders('xa') #x is included since x is generated sequentially
self.decoder_y_l = self.decoder.create_placeholders('y')
self.decoder_hyper_l = self.decoder.create_placeholders('hyper')
decoder_loss_l, ppl_fw_l, ppl_bw_l, ppl_l = self.decoder.forward(self.decoder_xa_l, self.decoder_y_l, z_pst, self.decoder_hyper_l)
elbo_l = encoder_loss_l * self.klw + decoder_loss_l - pri_loss_l
self.loss_l = elbo_l
self.loss_c = classifier_loss_l
with tf.name_scope('unlabeled'):
with tf.variable_scope('classifier', reuse=True):
self.classifier_xa_u = self.classifier.create_placeholders('xa')
self.classifier_hyper_u = self.classifier.create_placeholders('hyper')
logits_u = self.classifier.forward(self.classifier_xa_u, self.classifier_hyper_u)
predict_u = tf.nn.softmax(logits_u)
classifier_entropy_u = tf.losses.softmax_cross_entropy(predict_u, predict_u)
encoder_loss_u, decoder_loss_u = [], []
elbo_u = []
self.encoder_xa_u = self.encoder.create_placeholders('xa')
self.encoder_hyper_u = self.encoder.create_placeholders('hyper')
self.decoder_xa_u = self.decoder.create_placeholders('xa')
self.decoder_hyper_u = self.decoder.create_placeholders('hyper')
batch_size = tf.shape(list(self.encoder_xa_u.values())[0])[0]
for idx in range(self.n_class):
with tf.variable_scope('encoder', reuse=True):
_label = tf.gather(tf.eye(self.n_class), idx)
_label = tf.tile(_label[None, :], [batch_size, 1])
_z_pst, _, _encoder_loss = self.encoder.forward(self.encoder_xa_u, {'y':_label}, self.encoder_hyper_u)
encoder_loss_u.append(_encoder_loss * self.klw)
_pri_loss_u = tf.log(tf.gather(self.pri_prob_y, idx))
with tf.variable_scope('decoder', reuse=True):
_decoder_loss, _, _, _ = self.decoder.forward(self.decoder_xa_u, {'y':_label}, _z_pst, self.decoder_hyper_u)
decoder_loss_u.append(_decoder_loss)
_elbo_u = _encoder_loss * self.klw + _decoder_loss# - _pri_loss_u
elbo_u.append(_elbo_u)
self.loss_u = tf.add_n([elbo_u[idx] * predict_u[:, idx] for idx in range(self.n_class)]) + classifier_entropy_u
self.loss = tf.reduce_mean(self.loss_l + classifier_loss_l * alpha + self.loss_u)
self.loss += sum(tf.losses.get_regularization_losses())
batch_size_l = tf.shape(decoder_loss_l)[0]
decoder_loss_l = tf.reduce_mean(decoder_loss_l)
with tf.name_scope('train'):
#optimizer = tf.train.AdamOptimizer(learning_rate=self.learning_rate).minimize(cost, global_step=self.global_step)
optimizer = self.training_op(self.loss, tf.trainable_variables(), self.grad_clip, 20, self.learning_rate, opt='Adam')
summary_kl = tf.summary.scalar('kl', tf.reduce_mean(encoder_loss_l))
summary_loss = tf.summary.scalar('loss', self.loss)
summary_loss_l = tf.summary.scalar('loss_l', tf.reduce_mean(self.loss_l))
summary_loss_u = tf.summary.scalar('loss_u', tf.reduce_mean(self.loss_u))
summary_acc = tf.summary.scalar('acc', classifier_acc_l)
summary_ppl_fw = tf.summary.scalar('ppl_fw', ppl_fw_l)
summary_ppl_bw = tf.summary.scalar('ppl_bw', ppl_bw_l)
summary_ppl = tf.summary.scalar('ppl', ppl_l)
train_summary_op = tf.summary.merge_all()
test_acc = tf.placeholder(tf.float32, [])
test_ppl = tf.placeholder(tf.float32, [])
summary_acc_test = tf.summary.scalar('test_acc', test_acc)
summary_ppl_test = tf.summary.scalar('test_ppl', test_ppl)
test_summary_op = tf.summary.merge([summary_acc_test, summary_ppl_test])
logger = ExpLogger('semi_tabsa', save_dir)
logger.write_args(FLAGS)
logger.write_variables(tf.trainable_variables())
logger.file_copy(['semi_tabsa.py', 'encoder/*.py', 'decoder/*.py', 'classifier/*.py'])
summary_writer = tf.summary.FileWriter(save_dir + '/', sess.graph)
#test_summary_writer = tf.summary.FileWriter(save_dir + '/', sess.graph)
#validate_summary_writer = tf.summary.FileWriter(save_dir + '/validate', sess.graph)
sess.run(tf.global_variables_initializer())
def get_batch(dataset):
""" to get batch from an iterator, whenever the ending is reached. """
while True:
try:
batch = dataset.next()
break
except:
pass
return batch
def get_feed_dict_help(plhs, data_dict, keep_rate, is_training):
plh_dict = {}
for plh in plhs: plh_dict.update(plh)
data_dict.update({'keep_rate': keep_rate})
data_dict.update({'is_training': is_training})
feed_dict = self.get_feed_dict(plh_dict, data_dict)
return feed_dict
max_acc, max_f1 = 0., 0.
for i in range(n_iter):
#for train, _ in self.get_batch_data(train_data, keep_rate):
for samples, in train_data_l:
feed_dict_clf_l = get_feed_dict_help(plhs=[self.classifier_xa_l, self.classifier_y_l, self.classifier_hyper_l],
data_dict=self.classifier.prepare_data(samples),
keep_rate=keep_rate,
is_training=True)
feed_dict_enc_l = get_feed_dict_help(plhs=[self.encoder_xa_l, self.encoder_y_l, self.encoder_hyper_l],
data_dict=self.encoder.prepare_data(samples),
keep_rate=keep_rate,
is_training=True)
feed_dict_dec_l = get_feed_dict_help(plhs=[self.decoder_xa_l, self.decoder_y_l, self.decoder_hyper_l],
data_dict=self.decoder.prepare_data(samples),
keep_rate=keep_rate,
is_training=True)
samples, = get_batch(train_data_u)
feed_dict_clf_u = get_feed_dict_help(plhs=[self.classifier_xa_u, self.classifier_hyper_u],
data_dict=self.classifier.prepare_data(samples),
keep_rate=keep_rate,
is_training=True)
feed_dict_enc_u = get_feed_dict_help(plhs=[self.encoder_xa_u, self.encoder_hyper_u],
data_dict=self.encoder.prepare_data(samples),
keep_rate=keep_rate,
is_training=True)
feed_dict_dec_u = get_feed_dict_help(plhs=[self.decoder_xa_u, self.decoder_hyper_u],
data_dict=self.decoder.prepare_data(samples),
keep_rate=keep_rate,
is_training=True)
feed_dict = {}
feed_dict.update(feed_dict_clf_l)
feed_dict.update(feed_dict_enc_l)
feed_dict.update(feed_dict_dec_l)
feed_dict.update(feed_dict_clf_u)
feed_dict.update(feed_dict_enc_u)
feed_dict.update(feed_dict_dec_u)
feed_dict.update({self.klw: 0.0001})
_, _acc, _loss, _ppl, _step, summary = sess.run([optimizer, classifier_acc_l, decoder_loss_l, ppl_l, self.global_step, train_summary_op], feed_dict=feed_dict)
summary_writer.add_summary(summary, _step)
if np.random.rand() < 1/4:
print(_acc, _loss, _ppl, _step)
truth, pred, acc, ppl, loss, cnt = [], [], 0., 0., 0., 0
idx2y = {0:'positive', 1:'negative', 2:'neutral'}
for samples, in test_data:
feed_dict_clf_l = get_feed_dict_help(plhs=[self.classifier_xa_l, self.classifier_y_l, self.classifier_hyper_l],
data_dict=self.classifier.prepare_data(samples),
keep_rate=1.0,
is_training=False)
feed_dict_enc_l = get_feed_dict_help(plhs=[self.encoder_xa_l, self.encoder_y_l, self.encoder_hyper_l],
data_dict=self.encoder.prepare_data(samples),
keep_rate=1.0,
is_training=False)
feed_dict_dec_l = get_feed_dict_help(plhs=[self.decoder_xa_l, self.decoder_y_l, self.decoder_hyper_l],
data_dict=self.decoder.prepare_data(samples),
keep_rate=1.0,
is_training=False)
feed_dict = {}
feed_dict.update(feed_dict_clf_l)
feed_dict.update(feed_dict_enc_l)
feed_dict.update(feed_dict_dec_l)
feed_dict.update({self.klw: 0})
num, _pred, _acc, _loss, _ppl, _step = sess.run([batch_size_l, pred_l, classifier_acc_l, decoder_loss_l, ppl_l, self.global_step], feed_dict=feed_dict)
pred.extend([idx2y[int(_)] for _ in _pred])
truth.extend([sample['polarity'] for sample in samples])
acc += _acc * num
ppl += _ppl * num
loss += _loss * num
cnt += num
#print(cnt)
#print(acc)
f1 = f1_score(truth, pred, average='macro')
summary, _step = sess.run([test_summary_op, self.global_step], feed_dict={test_acc: acc/cnt, test_ppl: ppl/cnt})
summary_writer.add_summary(summary, _step)
logger.info('Iter {}: mini-batch loss={:.6f}, test acc={:.6f}, f1={:.6f}'.format(_step, loss / cnt, acc / cnt, f1))
print(save_dir)
if acc / cnt > max_acc:
max_acc = acc / cnt
max_f1 = f1
with open(os.path.join(save_dir, 'pred'), 'w') as f:
idx2y = {0:'positive', 1:'negative', 2:'neutral'}
for samples, in test_data:
feed_dict = get_feed_dict_help(plhs=[self.classifier_xa_l, self.classifier_y_l, self.classifier_hyper_l],
data_dict=self.classifier.prepare_data(samples),
keep_rate=1.0,
is_training=False)
_pred, = sess.run([pred_l], feed_dict=feed_dict)
for idx, sample in enumerate(samples):
f.write(idx2y[_pred[idx]])
f.write('\t')
f.write(sample['polarity'])
f.write('\t')
f.write(' '.join([t + ' ' + str(b) for (t, b) in zip(sample['tokens'], sample['tags'])]))
f.write('\n')
logger.info('Optimization Finished! Max acc={} f1={}'.format(max_acc, max_f1))
logger.info('Learning_rate={}, iter_num={}, hidden_num={}, l2={}'.format(
self.learning_rate,
n_iter,
self.n_hidden,
self.l2_reg
))