def decode(hparams):
hp = hparams
# data_feeder
coord = tf.train.Coordinator()
feeder = DataFeeder(coord, hp, False)
symbol = Symbol(hp.vocab_path, hp.poly_dict_path)
# construct model
inputs, target_lengths, targets, poly_mask = feeder.dequeue()
model = Poly_Model(hp, feeder.input_dim, feeder.num_class)
model.initialize(inputs, target_lengths, targets, poly_mask)
test_accuracy = model.accuracy
predict_seq = model.pred
saver = tf.train.Saver()
with tf.Session() as sess:
feeder.start_in_session(sess)
sess.run(tf.global_variables_initializer())
if not restore_from_ckpt(sess, saver, hp.save_dir): sys.exit(-1)
test_acc = 0
num_batchs = int(feeder.num_samples / hp.batch_size)
tmp = 0
correct = 0
total = 0
for i in range(num_batchs):
# print(i)
pred, acc, a, c, tag = sess.run([
predict_seq, test_accuracy, model.outputs, targets,
model.target_seq
])
# print(pred)
# print(a)
# print(b)
# print(c)
# print("Pred Seq: {}".format(pred))
# print(a)
# np.savetxt("{}.out".format(tmp), a[0], fmt='%1.4e')
# print(pred)
for pred_poly_seq in symbol.sequence_to_label(pred):
print("\t".join(pred_poly_seq))
for ta in symbol.sequence_to_label(tag):
print("\t".join(ta))
for pred_poly_seq, ta in zip(symbol.sequence_to_label(pred),
symbol.sequence_to_label(tag)):
if len(pred_poly_seq) != len(ta):
print("length not equal")
print("-----------------")
continue
for p, t in zip(pred_poly_seq, ta):
if t == "-":
continue
if p == t:
correct += 1
total += 1
test_acc += acc
tmp += 1
test_acc /= float(num_batchs)
tf.logging.info("Test Accuracy : {}".format(test_acc))
tf.logging.info("Test Accuracy New: {}".format(
float(correct) / float(total)))
def count_polY_accuracy(model, num_batchs, sess, save_dir):
symbol = Symbol(hp.vocab_path, hp.poly_dict_path)
with open(hp.poly_dict_path, 'r') as f:
POLY_DICT = json.load(f)
test_poly_dict = {}
for key, value in POLY_DICT.items():
POLY_DICT[key] = sorted(value)
test_poly_dict[key] = np.zeros((len(value), len(value)))
for i in range(num_batchs):
model_inputs, model_pre, mask, poly_mask, model_correct_pred, model_acc, model_outputs, model_targets, model_target_seq \
= sess.run([model.inputs, model.pred, model.mask, model.poly_mask, model.correct_pred, model.accuracy, model.outputs, model.targets, model.target_seq])
print("model_pred", model_pre)
print("model_accruacy", model_acc)
print("model_outputs", model_outputs)
print("model_mask", mask)
print("model_poly_mask", poly_mask)
print("model_targets", model_targets)
print("model_target_seq", model_target_seq)
print("model_correct_pred", model_correct_pred)
for pred_poly_seq, ta, model_input in zip(model_pre, model_target_seq,
model_inputs):
pred_poly = symbol.sequence_to_label(pred_poly_seq)
target_poly = symbol.sequence_to_label(ta)
word_value = symbol.input_to_word_value(model_input)
print(pred_poly)
print(target_poly)
print(word_value)
if len(pred_poly_seq) != len(ta):
print("length not equal")
print("-----------------")
continue
for p, t, w in zip(pred_poly, target_poly, word_value):
if t == "-":
continue
else:
i = POLY_DICT[w].index(p)
j = POLY_DICT[w].index(t)
test_poly_dict[w][i, j] += 1
print(w)
print(test_poly_dict[w])
print("Model Accuracy: {}".format(model_acc))
poly_accuracy_out = open(os.path.join(save_dir, "accuracy.out"), "w")
poly_count = open(os.path.join(save_dir, "poly_count.out"), "w")
for key, value in test_poly_dict.items():
accuracy = np.trace(value) / np.sum(value)
poly_accuracy_out.writelines("{}\t{}\t{}\t{}\n".format(
key, int(np.sum(value)), int(np.trace(value)), accuracy))
poly_count.writelines(key + "\n")
for i, poly_i in enumerate(POLY_DICT[key]):
for j, poly_j in enumerate(POLY_DICT[key]):
poly_count.write("{}->{}:{}\n".format(poly_i, poly_j,
int(value[i, j])))
