def test_model(self, file=None):
'''-----------------------------------------------
Step 1: Get model from file
-----------------------------------------------'''
# todo: best model
if file is None:
file = "train" + "_e_{}_".format(
config.epochs) + "all" + ".pth.tar"
folder = os.path.join(config.log_folder, 'train')
if os.path.exists(folder):
file = os.path.join(folder, file)
else:
print('Train dir or file {} doesn\'t exist'.format(folder))
sys.exit()
else:
file = file
if os.path.exists(file):
self.load_model(file)
else:
print('Train file doesn\'t exist... {}'.format(file))
sys.exit()
'''-----------------------------------------------
Step 2: Get data_loaders
-----------------------------------------------'''
start = time.time()
test_loader = get_data("test")
self.model.eval()
batch_idx = 1
total_batch = len(test_loader)
'''------------------------------------------------------------
3: Get batches from loader and pass to evaluate
------------------------------------------------------------'''
for input_tensor, target_tensor, input_lens, output_lens in test_loader:
print('\t---Test Batch: {}/{}---'.format(batch_idx, total_batch))
self.test_a_batch(input_tensor, target_tensor, input_lens,
output_lens)
batch_idx += 1
return True
def train_model(self, is_resume=False, epoch=-1, file=None):
'''-----------------------------------------------
Step 1: From scratch or resume
-----------------------------------------------'''
print(is_resume, epoch, file)
if is_resume: # resume training
print('resume traing')
if epoch != -1 and file is None:
file = "train" + "_e_{}_".format(epoch) + "all" + ".pth.tar"
else:
file = file
#print(file)
if os.path.exists(self.train_dir):
file = os.path.join(self.train_dir, file)
if os.path.exists(file):
s_epoch, train_loss = self.load_model(file)
time_stamp = str(int(time.time()))
file = "r_"+ str(s_epoch)+ "_print_data_" + time_stamp + ".csv"
print_file = os.path.join(config.out_folder, file)
file = "r_"+ str(s_epoch)+ "_plot_data_" + time_stamp + ".csv"
plot_file = os.path.join(config.out_folder, file)
else:
print('train file doesn\'t exist... {}'.format(file))
sys.exit()
else:
print('Train dir {} doesn\'t exist'.format(self.train_dir))
sys.exit()
else:
print('start from scratch')
s_epoch = 1
train_loss = 0
time_stamp = str(int(time.time()))
file = "print_data_" + time_stamp + ".csv"
print_file = os.path.join(config.out_folder, file)
file = "plot_data_" + time_stamp + ".csv"
plot_file = os.path.join(config.out_folder, file)
'''-----------------------------------------------
Step 2: Set required variables and get from config
-----------------------------------------------'''
eval_loss = 0
best_eval_loss = float('inf')
plot_train_loss_total = 0
plot_eval_loss_total = 0
e_epoch = config.epochs
print_every = config.print_every
plot_every = config.plot_every
#print('s_epoch: {}, e_epoch: {}, train_loss: {}, eval_loss: {}'.format(s_epoch, e_epoch, train_loss, eval_loss))
'''-----------------------------------------------
Step 3: Get data_loaders
-----------------------------------------------'''
train_loader = get_data("train")
eval_loader = get_data("val")
'''-----------------------------------------------
Step 4: Training and evluation using train and val sets
-----------------------------------------------'''
last_epoch = False
for epoch in range(s_epoch, e_epoch+1):
print('--------Epoch:{} starts--------\n'.format(epoch))
start_time = datetime.now()
print('train_loss: {}, eval_loss: {}'.format(train_loss, eval_loss))
if epoch == e_epoch:
last_epoch = True
file, train_loss = self.start_training(last_epoch, epoch, train_loss, train_loader)
file, eval_loss, best_eval_loss = self.start_evaluation(epoch, eval_loss, best_eval_loss, eval_loader)
end_time = datetime.now()
time_diff = get_time(start_time, end_time)
'''------------------------------------------------------------
5: print and plot data
------------------------------------------------------------'''
plot_train_loss_total += train_loss
plot_eval_loss_total += eval_loss
print('\nEpoch: {}/{} ==> {:.0f}% | Time: {}'.format(epoch, e_epoch, epoch/e_epoch*100, time_diff))
print_row = build_row(epoch, train_loss, eval_loss, best_eval_loss, time_diff)
print_writer(print_file, print_row)
if epoch % plot_every == 0:
plot_train_loss_avg = plot_train_loss_total/plot_every
#plot_train_loss_avg/=100 # to normalize for plotting
plot_eval_loss_avg = plot_eval_loss_total/plot_every
#plot_eval_loss_avg/=100 # to normalize
plot_row = build_row(epoch, plot_train_loss_avg, plot_eval_loss_avg)
plot_writer(plot_file, plot_row)
plot_train_loss_total = 0
plot_eval_loss_total = 0
train_loss = 0 # reset
eval_loss = 0
showPlot(config.out_folder, plot_file)
def read_data_sets(FLAGS, dtype=tf.float32):
train_dir = FLAGS.train_dir
class DataSets(object):
pass
data_sets = DataSets()
# define file names
TRAIN_FILE = train_dir + '/' + FLAGS.train_file
TRAIN_TEST_FILE = train_dir + '/' + FLAGS.train_test_file
DEV_FILE = train_dir + '/' + FLAGS.dev_file
DEVTEST_FILE = train_dir + '/' + FLAGS.test_file
# DICT_FILE = train_dir + '/hypernym_vocab.txt'
DICT_FILE = train_dir + '/vocabulary.txt'
REL_FILE = train_dir + '/rel.txt'
# read in all files using loader_utils functions
word2idx, idx2word = loader_utils.get_vocab(DICT_FILE)
rel2idx = loader_utils.get_relation(REL_FILE)
train_data = loader_utils.get_data(TRAIN_FILE, word2idx, rel2idx)
train_test_data = loader_utils.get_data(TRAIN_TEST_FILE, word2idx, rel2idx)
dev_data = loader_utils.get_data(DEV_FILE, word2idx, rel2idx)
devtest_data = loader_utils.get_data(DEVTEST_FILE, word2idx, rel2idx)
#
# print('train data', train_data[:10])
# print('dev data', dev_data[:10])
# print('devtest data', devtest_data[:10])
data_sets.train = DataSet(train_data)
data_sets.train_test = DataSet(train_test_data)
data_sets.dev = DataSet(dev_data)
data_sets.devtest = DataSet(devtest_data)
data_sets.word2idx = word2idx
data_sets.idx2word = idx2word
data_sets.rel2idx = rel2idx
data_sets.vocab_size = len(word2idx)
if FLAGS.w2 > 0.0:
# if the loss term minimize marginal prob as well, then read in the marginal file
MARG_FILE = train_dir + '/' + FLAGS.marg_prob_file
marginal_prob = loader_utils.get_count(MARG_FILE)
data_sets.margina_prob = marginal_prob
# if embeddings are initialized using pre trained model, then read them in
if FLAGS.init_embedding == 'pre_train':
print("Loading pre-trained model from file:",
FLAGS.init_embedding_file)
trained_model = pickle.load(open(FLAGS.init_embedding_file, "rb"))
# min_embed = trained_model['embeddings']
# delta_embed = trained_model['imag_embeddings']
min_embed = trained_model['min_embeddings']
delta_embed = trained_model['delta_embeddings']
data_sets.min_embed = min_embed
data_sets.delta_embed = delta_embed
# data_sets.min_embed = read_txt_embed(train_dir+'/tiny_test_min.txt')
# data_sets.delta_embed = read_txt_embed(train_dir+'/tiny_test_delta.txt')
# if evaluation method is taxonomy evaluation which may be used when evaluate wordnet data, then read all taxo eval related stuff in.
if FLAGS.eval == 'taxo':
TAXO_DEV_FILE = train_dir + '/wordnet_taxo_dev_single.txt'
TAXO_TEST_FILE = train_dir + '/wordnet_taxo_dev_single.txt'
taxo_dev = loader_utils.get_taxo_words(TAXO_DEV_FILE, word2idx)
taxo_test = loader_utils.get_taxo_words(TAXO_TEST_FILE, word2idx)
taxo_dev_parents = get_wordnet_synset_parents(taxo_dev, word2idx,
idx2word)
taxo_test_parents = get_wordnet_synset_parents(taxo_test, word2idx,
idx2word)
data_sets.taxo_dev = taxo_dev
data_sets.taxo_test = taxo_test
data_sets.taxo_dev_parents = taxo_dev_parents
data_sets.taxo_test_parents = taxo_test_parents
return data_sets