def get_inference_model(path):
model_train, model_encoder, model_decoder = define_nmt(
num_words, embedding_size, hidden_size)
try:
print("Get inference model {}".format(path))
model_train.load_weights(path)
except Exception as error:
print(error)
print("Error trying to load checkpoint.")
return (model_encoder, model_decoder)
def build_member(lr, dropout):
model, encoder_model, decoder_model = \
define_nmt(hidden_size, embedding_size, timesteps,
en_vocab_size, de_vocab_size, dropout, np.power(10, lr))
return Member(model,
param_names=['lr', 'dropout'],
tune_lr=True,
use_eval_metric='bleu',
custom_metrics={
'bleu':
lambda x, y, _: bleu_score_enc_dec(
encoder_model, decoder_model, x, y, batch_size)
})
def build_member(lr, dropout):
'''
Building baseline model using lr and dropout rates passed
in terms of parameters
For each member we pass our parameters, tune the learning rate,
using BLEU as our performance metric.
'''
model, encoder_model, decoder_model = \
define_nmt(hidden_size, embedding_size, timesteps,
en_vocab_size, de_vocab_size, dropout, np.power(10, lr))
return Member(model,
param_names=['lr', 'dropout'],
tune_lr=True,
use_eval_metric='bleu',
custom_metrics={
'bleu':
lambda x, y, _: bleu_score_enc_dec(
encoder_model, decoder_model, x, y, batch_size)
})
val_size = 3200
en_train_t, en_train_v = en_train[val_size:], en_train[:val_size]
de_train_t, de_train_v = de_train[val_size:], de_train[:val_size]
# model parameters
hidden_size = 96
embedding_size = 100
timesteps = 30
# hyperparameters
lr = 0.001
dropout = 0.2
model, encoder_model, decoder_model = define_nmt(hidden_size,
embedding_size, timesteps,
en_vocab_size,
de_vocab_size, dropout,
lr)
train_generator = nmt_train_generator(en_train_t, de_train_t,
de_vocab_size, batch_size)
steps = en_train.shape[0] // batch_size
eval_every = 100
bleu_logger = BleuLogger((en_train_v, de_train_v), eval_every, batch_size,
de_vocab_size, encoder_model, decoder_model)
model.fit_generator(train_generator,
steps_per_epoch=steps,
callbacks=[bleu_logger])
tokenizer_eng = keras.preprocessing.text.Tokenizer(oov_token='UNK')
tokenizer_eng.fit_on_texts(eng_text)
tokenizer_ger = keras.preprocessing.text.Tokenizer(oov_token='UNK')
tokenizer_ger.fit_on_texts(ger_text)
""" Getting preprocessed data """
eng_seq, ger_seq = preprocess_data(tokenizer_eng, tokenizer_ger, eng_text,
ger_text, eng_timesteps, ger_timesteps)
eng_vocab_size = max(tokenizer_eng.index_word.keys()) + 1
ger_vocab_size = max(tokenizer_ger.index_word.keys()) + 1
""" Defining the full model """
full_model, infer_enc_model, infer_dec_model = define_nmt(
hidden_size=hidden_size,
batch_size=batch_size,
eng_timesteps=eng_timesteps,
ger_timesteps=ger_timesteps,
eng_vocab_size=eng_vocab_size,
ger_vocab_size=ger_vocab_size)
n_epochs = 1 if not debug else 3
train(full_model, eng_seq, ger_seq, batch_size, n_epochs)
""" Save model """
if not os.path.exists(os.path.join('..', 'h5.models')):
os.mkdir(os.path.join('..', 'h5.models'))
full_model.save(os.path.join('..', 'h5.models', 'nmt.h5'))
""" Index2word """
en_index2word = dict(
zip(en_tokenizer.word_index.values(), en_tokenizer.word_index.keys()))
fr_index2word = dict(
zip(fr_tokenizer.word_index.values(), fr_tokenizer.word_index.keys()))