parser.add_argument("-r", "--restoreDir", help="Directory to restore from", required=False)
args = parser.parse_args()
print "Loading config"
config = getConfig()
print "Loading embeddings"
embed = np.loadtxt(args.inDir + "/embed.txt", dtype=np.float32)
print "Loading Dev Data"
devData = utils.loadComments(args.inDir + "/ProcessedDev", float('inf'), config)
# Additional configs
config["vocabSize"] = len(embed)
config["embedDim"] = len(embed[0])
config["numClasses"] = len(devData[5][0])
config["numCommentfs"] = len(devData[4][0])
utils.printConfig(config)
config["saveDir"] = None
config["restoreDir"] = args.restoreDir
print "Evaluating"
devPredictions = evaluate(embed, devData, config)
labelCommentsWithSoft(
"../statsout/T49/summaryPred.json",
"../statsout/T49/summaryPred2.json",
devPredictions)
def log(self,
epoch,
train_loss,
train_accy,
valid_accy,
validate_start,
fts_means,
pred_lbls,
best_acc,
ebd_loss=None,
old_train_accy=None):
printConfig(self.args, self.f, self.optimizer)
if self.increment_phase > 0:
info = 'Epoch: {}, New_Train_loss: {:.4f}, ebd_loss: {:.4f}, New_Train_accy(KNN, NCM): ' \
'{:.4f}, {:.4f}, Old_Train_accy(KNN, NCM): {:.4f}, {:.4f},' \
'Valid_accy(KNN, NCM): {:.4f}, {:.4f}, Consumed: {}s\n'.format(
epoch, train_loss, ebd_loss, train_accy[0], train_accy[1], old_train_accy[0],
old_train_accy[1], valid_accy[0], valid_accy[1],
(datetime.datetime.now() - validate_start).seconds)
else:
info = 'Epoch: {}, Train_loss: {:.4f}, Train_accy(KNN, NCM): {:.4f}, {:.4f}, ' \
'Valid_accy(KNN, NCM): {:.4f}, {:.4f}, Consumed: {}s\n'.format(
epoch, train_loss, train_accy[0], train_accy[1], valid_accy[0], valid_accy[1],
(datetime.datetime.now() - validate_start).seconds)
print(info)
self.f.write(info + '\r\n')
self.writer.add_scalar(tag='Triplet loss',
scalar_value=train_loss,
global_step=epoch)
self.writer.add_scalar(tag='Train acc(KNN)',
scalar_value=train_accy[0],
global_step=epoch)
self.writer.add_scalar(tag='Train acc(NCM)',
scalar_value=train_accy[1],
global_step=epoch)
self.writer.add_scalar(tag='Valid acc(KNN)',
scalar_value=valid_accy[0],
global_step=epoch)
self.writer.add_scalar(tag='Valid acc(NCM)',
scalar_value=valid_accy[1],
global_step=epoch)
if self.increment_phase > 0:
self.writer.add_scalar(tag='Distillation loss',
scalar_value=ebd_loss,
global_step=epoch)
self.writer.add_scalar(tag='Old Train acc(KNN)',
scalar_value=old_train_accy[0],
global_step=epoch)
self.writer.add_scalar(tag='Old Train acc(NCM)',
scalar_value=old_train_accy[1],
global_step=epoch)
print('Saving...\n')
#######################################################################################
if valid_accy[1] > best_acc or epoch == self.args.epoch:
# Confusion ##########################################################################
confusion = confusion_matrix(y_true=self.valid_lbls,
y_pred=pred_lbls)
plot_confusion_matrix(cm=confusion,
classes=self.classes,
save_path=os.path.join(
self.save_path['path_cm'],
'cm_{}.png'.format(epoch)))
# train set ##############################################################################
with torch.no_grad():
benchmark = self.getEmbeddings(model=self.model,
loader=self.train_loader)
all_train_fts, all_train_lbls = benchmark
self.writer.add_embedding(global_step=epoch,
mat=all_train_fts,
metadata=all_train_lbls)
# test set ##############################################################################
with torch.no_grad():
benchmark = self.getEmbeddings(model=self.model,
loader=self.test_loader)
all_test_fts, all_test_lbls = benchmark
self.writer.add_embedding(global_step=epoch + 1000,
mat=all_test_fts,
metadata=all_test_lbls)
# train+test ##############################################################################
all_fts = torch.cat((all_train_fts, all_test_fts))
all_lbls = torch.cat((all_train_lbls, all_test_lbls))
self.writer.add_embedding(global_step=epoch + 2000,
mat=all_fts,
metadata=all_lbls)
if self.increment_phase > 0:
# Old train set ###########################################################################
with torch.no_grad():
benchmark = self.getEmbeddings(
model=self.model, loader=self.train_loader_old)
all_train_fts_old, all_train_lbls_old = benchmark
self.writer.add_embedding(global_step=epoch + 3000,
mat=all_train_fts_old,
metadata=all_train_lbls_old)
# New train + Old train ##################################################################
new_old = torch.cat((all_train_fts, all_train_fts_old))
new_old_lbl = torch.cat((all_train_lbls, all_train_lbls_old))
self.writer.add_embedding(global_step=epoch + 4000,
mat=new_old,
metadata=new_old_lbl)
# old train + test ########################################################################
old_test = torch.cat((all_train_fts_old, all_test_fts))
old_test_lbl = torch.cat((all_train_lbls_old, all_test_lbls))
self.writer.add_embedding(global_step=epoch + 5000,
mat=old_test,
metadata=old_test_lbl)
# Sparsity ##########################################################################
fts_means = fts_means.cpu().data.numpy(
) if fts_means.is_cuda else fts_means.data.numpy()
save_dir = os.path.join(self.save_path['path_sparsity'],
'{}'.format(epoch))
# makedirs(save_dir) # make directory for histograms
if not os.path.exists(save_dir):
os.makedirs(save_dir)
plot_sparsity_histogram(features=fts_means,
idx_to_name=self.classes,
save_dir=save_dir)
