eval.py

from model import create_model
from utility.utility import load_training_data, load_validation_data
from utility.language_encoder import LanguageEncoder
import numpy as np
from keras.models import load_model
import pathlib
import pickle
import sys

def inference(inference_model, source):
    output_sentence = [target_le.transform_word("<START>")]
    output_sentence_array = np.array([target_le.transform_word("<START>")] + [target_le.transform_word("<NULL>")]*(MAXIMUM_TEXT_LENGTH-1)).reshape(1, -1)
    source = source.reshape(1, -1)

    current_word = None
    for t in range(MAXIMUM_TEXT_LENGTH-1):
        data = [source, output_sentence_array]

        output = inference_model.predict(data)
        words = np.argmax(output[0], -1)

        current_word = np.argmax(output[0, t])
        output_sentence.append(current_word)
        output_sentence_array[0, t] = current_word

        if current_word == target_le.transform_word("<STOP>"):
            break

    sentence = [target_le._index_word_map[i] for i in output_sentence[1:]]
    return " ".join(sentence) + " ({0})".format(len(output_sentence)-1)

pathlib.Path('./models').mkdir(exist_ok=True) 

MAXIMUM_TEXT_LENGTH = 70

source_le = LanguageEncoder.load("./data/en2de.language.source.pkl")
target_le = LanguageEncoder.load("./data/en2de.language.target.pkl")

with open("data/en2de.tokens.pkl", "rb") as f:
    (_, source_val), (_, target_val) = pickle.load(f)

print("source vocabulary size: " + str(source_le._vocabulary_size))
print("target vocabulary size: " + str(target_le._vocabulary_size))

source_val = [[source_le.transform_word("<START>")] + item + [source_le.transform_word("<STOP>")] for item in source_val]
target_val = [[target_le.transform_word("<START>")] + item + [target_le.transform_word("<STOP>")] for item in target_val]

source_val = [x[:MAXIMUM_TEXT_LENGTH-1] + [source_le.transform_word("<NULL>")]*(MAXIMUM_TEXT_LENGTH-len(x)) for x in source_val]
target_val = [x[:MAXIMUM_TEXT_LENGTH-1] + [target_le.transform_word("<NULL>")]*(MAXIMUM_TEXT_LENGTH-len(x)) for x in target_val]

source_val = np.array(source_val)
target_val = np.array(target_val)

model_id = input("Model ID: ")
model_id = int(model_id)

_, inference_model = create_model(source_le._vocabulary_size, target_le._vocabulary_size, MAXIMUM_TEXT_LENGTH, n=2, d_model=256, h=4)
try:
    inference_model.load_weights(f"./models/aiayn.inference.{model_id}.h5")
except:
    print("Could not load model from: " + f"./models/aiayn.inference.{model_id}.h5")
    sys.exit()

while True:
    max_idx = len(source_val)
    idx = input(f"Enter the sentence index (0-{max_idx}): ")
    idx = int(idx)
    if idx >= len(source_val):
        continue
    
    print("\ttarget: ")
    print("\t\t{0}".format(" ".join([target_le._index_word_map[x] for x in target_val[idx]])))

    print("\toutput:")
    print("\t\t{0}".format(inference(inference_model, source_val[idx])))
    print("")

input("done. <read key>")