def main():
g = ModelGraph()
with tf.Session() as sess:
tf.sg_init(sess)
# restore parameters
saver = tf.train.Saver()
saver.restore(sess, tf.train.latest_checkpoint('asset/train/ckpt'))
hits = 0
num_imgs = 0
with tf.sg_queue_context(sess):
# loop end-of-queue
while True:
try:
logits, y = sess.run([g.logits, g.y]) # (16, 28)
preds = np.squeeze(np.argmax(logits, -1)) # (16,)
hits += np.equal(preds, y).astype(np.int32).sum()
num_imgs += len(y)
print "%d/%d = %.02f" % (hits, num_imgs, float(hits) / num_imgs)
except:
break
print "\nFinal result is\n%d/%d = %.02f" % (hits, num_imgs, float(hits) / num_imgs)
def main():
g = ModelGraph(mode="test")
with tf.Session() as sess:
tf.sg_init(sess)
# restore parameters
saver = tf.train.Saver()
if Hyperparams.isqwerty:
save_path = "qwerty/asset/train/ckpt"
else:
save_path = "nine/asset/train/ckpt"
saver.restore(sess, tf.train.latest_checkpoint(save_path))
mname = open(save_path + "/checkpoint", 'r').read().split('"')[1]
nums, X, expected_list = load_test_data()
pnyn2idx, idx2pnyn, hanzi2idx, idx2hanzi = load_vocab()
with codecs.open('data/output_{}.txt'.format(mname), 'w',
'utf-8') as fout:
cum_score = 0
full_score = 0
for step in range(len(X) // 64 + 1):
n = nums[step * 64:(step + 1) * 64] #number batch
x = X[step * 64:(step + 1) * 64] # input batch
e = expected_list[step * 64:(step + 1) *
64] # batch of ground truth strings
# predict characters
logits = sess.run(g.logits, {g.x: x})
preds = np.squeeze(np.argmax(logits, -1))
for nn, xx, pp, ee in zip(n, x, preds, e): # sentence-wise
got = ''
for xxx, ppp in zip(xx, pp): # character-wise
if xxx == 0: break
if xxx == 1 or ppp == 1:
got += "*"
else:
got += idx2hanzi.get(ppp, "*")
got = got.replace("_", "") # Remove blanks
error = distance.levenshtein(ee, got)
score = len(ee) - error
cum_score += score
full_score += len(ee)
fout.write(u"{}\t{}\t{}\t{}\n".format(nn, ee, got, score))
fout.write(u"Total acc.: {}/{}={}\n".format(
cum_score, full_score, round(float(cum_score) / full_score,
2)))
def main():
graph = ModelGraph("test")
with tf.Session() as sess:
tf.sg_init(sess)
# restore parameters
saver = tf.train.Saver()
saver.restore(sess, tf.train.latest_checkpoint('asset/train/ckpt'))
X, Y = load_data("test")
idx2chr = load_charmaps()[0]
with codecs.open('results.txt', 'w', 'utf-8') as fout:
results = []
for step in range(len(X) // Hyperparams.batch_size - 1):
X_batch = X[step * Hyperparams.batch_size:(step + 1) *
Hyperparams.batch_size]
Y_batch = Y[step * Hyperparams.batch_size:(step + 1) *
Hyperparams.batch_size]
# predict characters
logits = sess.run(graph.logits, {graph.X_batch: X_batch})
preds = np.squeeze(np.argmax(logits, -1))
for x, y, p in zip(X_batch, Y_batch, preds): # sentence-wise
ground_truth = ''
predicted = ''
for xx, yy, pp in zip(x, y, p): # character-wise
if xx == 0: break
else:
predicted += idx2chr.get(xx, "*")
ground_truth += idx2chr.get(xx, "*")
if pp == 1: predicted += " "
if yy == 1: ground_truth += " "
if pp == yy: results.append(1)
else: results.append(0)
fout.write(u"▌Expected: " + ground_truth + "\n")
fout.write(u"▌Got: " + predicted + "\n\n")
fout.write(u"Final Accuracy = %d/%d=%.2f" %
(sum(results), len(results),
float(sum(results)) / len(results)))
def main():
g = ModelGraph(mode="test")
with tf.Session() as sess:
tf.sg_init(sess)
# restore parameters
saver = tf.train.Saver()
saver.restore(sess, tf.train.latest_checkpoint('asset/train'))
print("Restored!")
mname = open('asset/train/checkpoint',
'r').read().split('"')[1] # model name
char2idx, idx2char = load_char_vocab()
word2idx, idx2word = load_word_vocab()
previous = [0] * 50 # a stack for previous words
para = "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"
ctx = [0] * 50
while True:
key = readchar.readkey().lower()
if key == readchar.key.BACKSPACE:
ctx.insert(0, previous.pop())
ctx.pop()
previous.insert(0, 0)
elif key == readchar.key.ESC:
break
else:
key_idx = char2idx[key]
ctx.append(key_idx)
ctx.pop(0)
logits = sess.run(g.logits, {g.x: np.expand_dims(ctx, 0)})
preds = logits.argsort()[0][-3:]
# pred = np.argmax(logits, -1)[0]
predword1, predword2, predword3 = [
idx2word.get(pred) for pred in preds
]
print(predword1, ' ', predword2, ' ', predword3)
def main():
g = ModelGraph(is_train=False)
with tf.Session() as sess:
tf.sg_init(sess)
# restore parameters
saver = tf.train.Saver()
saver.restore(sess, tf.train.latest_checkpoint('asset/train/ckpt'))
# Or you could use pretrained model which can be downloaded from here
# https://drive.google.com/open?id=0B5M-ed49qMsDQ1dEYXF3cTVNM1E
# saver.restore(sess, 'model-019-1239684')
sents, X = vectorize_input()
idx2hanja = load_charmaps()[-1]
with codecs.open('data/output.txt', 'w', 'utf-8') as fout:
for step in range(len(X) // Hyperparams.batch_size + 1):
inputs = sents[step * Hyperparams.batch_size:(step + 1) *
Hyperparams.batch_size] # batch
x = X[step * Hyperparams.batch_size:(step + 1) *
Hyperparams.batch_size] # batch
# predict characters
logits = sess.run(g.logits, {g.x: x})
preds = np.squeeze(np.argmax(logits, -1))
for ii, xx, pp in zip(inputs, x, preds): # sentence-wise
got = ''
for ii, xxx, ppp in zip(ii, xx, pp): # character-wise
if xxx == 0: break
elif xxx == 1 or ppp == 1:
got += ii
else:
got += idx2hanja.get(ppp, "*")
fout.write(got + "\n")
n = len(words)
latest_50_chars = string[-50:]
para = "E" * (50 - len(latest_50_chars)) + latest_50_chars
ctx = [char2idx[char] for char in para]
logits = sess.run(g.logits, {g.x: np.expand_dims(ctx, 0)})
preds = logits.argsort()[0][-3:]
predword1, predword2, predword3 = [idx2word.get(pred) for pred in preds]
return json.dumps([(predword1, ), (predword2, ), (predword3, )])
if __name__ == "__main__":
g = ModelGraph(mode="test")
with tf.Session() as sess:
tf.sg_init(sess)
saver = tf.train.Saver()
saver.restore(sess, tf.train.latest_checkpoint('asset/train'))
print('Restored')
char2idx, idx2char = load_char_vocab()
word2idx, idx2word = load_word_vocab()
previous = [0] * 50 # a stack for previous words
para = "EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE"
ctx = [0] * 50
app.run(debug=True)
def main():
g = ModelGraph(mode="test")
with tf.Session() as sess:
tf.sg_init(sess)
# restore parameters
saver = tf.train.Saver()
saver.restore(sess, tf.train.latest_checkpoint('asset/train'))
print("Restored!")
mname = open('asset/train/checkpoint',
'r').read().split('"')[1] # model name
X, Y = load_test_data()
char2idx, idx2char = load_char_vocab()
word2idx, idx2word = load_word_vocab()
results = []
rk = 0
num_para = 1
num_char = 1
for x, y in zip(X, Y):
stop_counting = False
x = np.concatenate(
(np.zeros((Hyperparams.seqlen - 1, )),
x[-np.count_nonzero(x):])) # lstrip and zero-pad
para = "".join([idx2char[idx] for idx in x])
chars, targets = [], [] # targets: the word that the char composes
for word in "".join(para).split():
chars.append(" ")
targets.append(word)
for char in word:
chars.append(char)
targets.append(word)
prefix = ""
preds = set()
for i, char_target in enumerate(zip(chars, targets)):
char, target = char_target
oov = ""
if target not in word2idx:
oov = "oov"
if i > Hyperparams.seqlen:
ctx = np.array(x[i - Hyperparams.seqlen:i], np.int32) #
if char == " ":
stop_counting = False
preds = set()
if not stop_counting:
logits = sess.run(
g.logits,
{g.x: np.expand_dims(ctx, 0)}) #(1, 20970)
while 1:
pred = np.argmax(logits, -1)[0] # (1,)
if pred in preds:
logits[:, pred] = -100000000
else:
break
rk += 1
predword = idx2word.get(pred)
if predword == target: # S
stop_counting = True
preds.add(pred)
results.append(u"{},{},{},{},{},{},{}".format(
num_char, num_para, char, target, oov, predword, rk))
num_char += 1
num_para += 1
with codecs.open('data/output_{}_rk_{}.csv'.format(mname, rk), 'w',
'utf-8') as fout:
fout.write("\n".join(results))