def _create_model(self, mode):
"""Create a new Seq2SeqModel."""
model_config = self.model_config
model_config['mode'] = mode
model_config['num_encoder_symbols'] = self.dictionary.n_tokens
model_config['num_decoder_symbols'] = self.dictionary.n_tokens
model_config['start_token'] = self.dictionary.SOS
model_config['end_token'] = self.dictionary.EOS
model_config['pad_token'] = self.dictionary.PAD
self.model = Seq2SeqModel(**model_config)
self.model.sess.graph.finalize()
print('Created model with config:')
print(json.dumps(model_config, indent=2))
def load_model():
checkpoint = torch.load(hp.checkpoint_name)
input_lang = pickle.load(open("input.dict", "rb"))
output_lang = pickle.load(open("output.dict", "rb"))
encoder = LSTMEncoderRNN(input_lang.n_words, hp.hidden_size, hp.embed_size)
decoder = LSTMAttnDecoderRNN(encoder, hp.attention, hp.hidden_size, output_lang.n_words)
encoder = encoder.cuda()
decoder = decoder.cuda()
encoder_state = checkpoint["encoder"]
decoder_state = checkpoint["decoder"]
encoder.load_state_dict(encoder_state)
decoder.load_state_dict(decoder_state)
seq2seq_model = Seq2SeqModel(encoder, decoder, input_lang, output_lang)
return seq2seq_model
from data import upload_dataset_partition from init_directories import init_directories from models import Seq2SeqModel init_directories() architecture = 5 word_level = 1 latent_dim = 350 epochs = 500 upload_dataset_partition(word_level=word_level, partitions=2) model = Seq2SeqModel(latent_dim=latent_dim, epochs=epochs, model_architecture=architecture, word_level=word_level) model.train_model()
num_epochs = 50
epoch_init = 0
best_loss = 1000
epochs_since_improvement = 0
# load pretrained word embeddings
embedding = np.load('glove_pretrained_weights.npy', allow_pickle=True)
embedding = torch.from_numpy(embedding).float()
model = Seq2SeqModel(
embed_dim=100,
vocab_size=3933,
dof=dof_num,
enc_dim=encoder_hidden_dim,
dec_dim=decoder_hidden_dim,
enc_layers=1,
dec_layers=1,
bidirectional=True,
# dropout_prob=0.5,
pretrain_weight=None)
# setting optimizer
optimizer = optim.Adam(model.parameters(), lr=learning_rate)
criterion = nopad_mse_loss(reduction='mean')
# load saved models
save_state_dict = torch.load(model_save_folder +
'last_checkpoint_Seq2Seq_0309')
# print(save_state_dict['model'])
model.load_state_dict(save_state_dict['model'])
else:
input_lang = pickle.load(open(hp.prefix + "input.dict", "rb"))
output_lang = pickle.load(open(hp.prefix + "output.dict", "rb"))
encoder = LSTMEncoderRNN(input_lang.n_words, hidden_size, embed_size)
decoder = LSTMAttnDecoderRNN(encoder, hp.attention, hidden_size,
output_lang.n_words)
if use_cuda:
encoder = encoder.cuda()
decoder = decoder.cuda()
print(encoder)
print(decoder)
seq2seq_model = Seq2SeqModel(encoder, decoder, input_lang, output_lang)
if os.path.isfile(hp.checkpoint_name):
checkpoint = torch.load(hp.checkpoint_name) if use_cuda else torch.load(
hp.checkpoint_name, map_location=lambda storage, loc: storage)
encoder_state = checkpoint["encoder"]
decoder_state = checkpoint["decoder"]
encoder_optimizer_state = checkpoint["encoder_optimizer"]
decoder_optimizer_state = checkpoint["decoder_optimizer"]
epoch = checkpoint["epoch"]
train_loss = checkpoint["train_loss"]
eval_loss = checkpoint["eval_loss"]
bleu_scores = checkpoint["bleu_scores"]
encoder.load_state_dict(encoder_state)
decoder.load_state_dict(decoder_state)