loss.backward()
optimizer.step()
# Tracking a running average of loss
if runningLoss is None:
runningLoss = loss.data[0]
else:
runningLoss = 0.95 * runningLoss + 0.05 * loss.data[0]
# Decay learning rate
if lRate > params['minLRate']:
for gId, group in enumerate(optimizer.param_groups):
optimizer.param_groups[gId]['lr'] *= params['lrDecayRate']
lRate *= params['lrDecayRate']
if iterId % 10 == 0: # Plot learning rate till saturation
viz.linePlot(iterId, lRate, 'learning rate', 'learning rate')
# RL Annealing: Every epoch after the first, decrease rlRound
if iterId % numIterPerEpoch == 0 and iterId > 0:
if params['trainMode'] == 'rl-full-QAf':
rlRound = max(0, rlRound - 1)
print('Using rl starting at round {}'.format(rlRound))
# Print every now and then
if iterId % 10 == 0:
end_t = timer() # Keeping track of iteration(s) time
curEpoch = float(iterId) / numIterPerEpoch
timeStamp = strftime('%a %d %b %y %X', gmtime())
printFormat = '[%s][Ep: %.2f][Iter: %d][Time: %5.2fs][Loss: %.3g]'
printFormat += '[lr: %.3g]'
printInfo = [
"Evaluating only on rounds in the category \"{}\"".format(
params['qaCategory']))
rankMetrics_category = rankABot_category_specific(
aBot,
dataset,
split,
params['qaCategory'],
category_mapping_splits[split],
scoringFunction=utils.maskedNll,
exampleLimit=None)
for metric, value in rankMetrics_category.items():
plotName = splitName + ' - ABot Rank'
viz.linePlot(iterId,
value,
plotName,
metric,
xlabel='Iterations')
logging.info("Metric \"{}\": {}".format(metric, value))
else:
logging.info(
"Evaluating on complete dataset, no category specification")
rankMetrics = rankABot(aBot,
dataset,
split,
scoringFunction=utils.maskedNll)
for metric, value in rankMetrics.items():
plotName = splitName + ' - ABot Rank'
viz.linePlot(iterId,
value,
split = "val"
splitName = "full Val - {}".format(params["evalTitle"])
print("Using split %s" % split)
dataset.split = split
# if params['evalModeList'] == 'ABotRank':
if "ABotRank" in params["evalModeList"]:
print("Performing ABotRank evaluation")
rankMetrics = rankABot(aBot,
dataset,
split,
scoringFunction=utils.maskedNll)
for metric, value in rankMetrics.items():
plotName = splitName + " - ABot Rank"
viz.linePlot(iterId, value, plotName, metric, xlabel="Iterations")
# if params['evalModeList'] == 'QBotRank':
if "QBotRank" in params["evalModeList"]:
print("Performing QBotRank evaluation")
rankMetrics, roundRanks = rankQBot(qBot, dataset, split, verbose=1)
for metric, value in rankMetrics.items():
plotName = splitName + " - QBot Rank"
viz.linePlot(iterId, value, plotName, metric, xlabel="Iterations")
for r in range(numRounds + 1):
for metric, value in roundRanks[r].items():
plotName = "[Iter %d] %s - QABots Rank Roundwise" % (iterId,
splitName)
viz.linePlot(r, value, plotName, metric, xlabel="Round")
if lm_nsp_loss is not None:
print_lm_nsp_loss = lm_nsp_loss.item()
if img_loss is not None:
print_img_loss = img_loss.item()
print_format = '[%s][Ep: %.2f][Iter: %d][Time: %5.2fs][NSP + LM Loss: %.3g][LM Loss: %.3g][NSP Loss: %.3g][IMG Loss: %.3g]'
print_info = [
timestamp, cur_epoch, iter_id, end_t - start_t,
print_lm_nsp_loss, print_lm_loss, print_nsp_loss,
print_img_loss
]
print(print_format % tuple(print_info))
start_t = end_t
# Update line plots
viz.linePlot(iter_id, loss.item(), 'loss', 'tot loss')
if lm_nsp_loss is not None:
viz.linePlot(iter_id, lm_nsp_loss.item(), 'loss',
'lm + nsp loss')
if lm_loss is not None:
viz.linePlot(iter_id, lm_loss.item(), 'loss', 'lm loss')
if nsp_loss is not None:
viz.linePlot(iter_id, nsp_loss.item(), 'loss', 'nsp loss')
if img_loss is not None:
viz.linePlot(iter_id, img_loss.item(), 'loss', 'img loss')
old_num_iter_epoch = num_iter_epoch
if params['overfit']:
num_iter_epoch = 100
if iter_id % num_iter_epoch == 0 and iter_id > 0:
torch.save({'model_state_dict' : dialog_encoder.module.state_dict(),'scheduler_state_dict':scheduler.state_dict() \
loss.backward()
optimizer.step()
# Tracking a running average of loss
if runningLoss is None:
runningLoss = loss.data[0]
else:
runningLoss = 0.95 * runningLoss + 0.05 * loss.data[0]
# Decay learning rate
if lRate > params['minLRate']:
for gId, group in enumerate(optimizer.param_groups):
optimizer.param_groups[gId]['lr'] *= params['lrDecayRate']
lRate *= params['lrDecayRate']
if iterId % 10 == 0: # Plot learning rate till saturation
viz.linePlot(iterId, lRate, 'learning rate', 'learning rate')
# RL Annealing: Every epoch after the first, decrease rlRound
if iterId % numIterPerEpoch == 0 and iterId > 0:
curEpoch = int(float(iterId) / numIterPerEpoch)
if curEpoch % params['annealingReduceEpoch'] == 0:
if params['trainMode'] == 'rl-full-QAf':
rlRound = max(params["annealingEndRound"], rlRound - 1)
if rlRound == params["annealingEndRound"]:
rlRound = params['numRounds'] - 1
print('Using rl starting at round {}'.format(rlRound))
# Print every now and then
if iterId % 10 == 0:
end_t = timer() # Keeping track of iteration(s) time
curEpoch = float(iterId) / numIterPerEpoch
print('Performing validation...')
if aBot and 'ques' in batch:
print("aBot Validation:")
# NOTE: A-Bot validation is slow, so adjust exampleLimit as needed
rankMetrics = rankABot(aBot,
dataset,
'val',
scoringFunction=utils.maskedNll,
exampleLimit=25 * params['batchSize'])
for metric, value in rankMetrics.items():
viz.linePlot(epochId,
value,
'val - aBot',
metric,
xlabel='Epochs')
if 'logProbsMean' in rankMetrics:
logProbsMean = params['CELossCoeff'] * rankMetrics[
'logProbsMean']
viz.linePlot(iterId, logProbsMean, 'aBotLoss', 'val CE')
if params['trainMode'] == 'sl-abot':
valLoss = logProbsMean
viz.linePlot(iterId, valLoss, 'loss', 'val loss')
if qBot:
print("qBot Validation:")
rankMetrics, roundMetrics = rankQBot(qBot, dataset, 'val')
