numIterPerEpoch = max(1, numIterPerEpoch)
count = 0
savePath = 'models/tasks_inter_%dH_%.4flr_%r_%d_%d.pickle' %\
(params['hiddenSize'], params['learningRate'], params['remember'],\
options['aOutVocab'], options['qOutVocab'])
matches = {}
accuracy = {}
bestAccuracy = 0
for iterId in xrange(params['numEpochs'] * numIterPerEpoch):
epoch = float(iterId) / numIterPerEpoch
# get double attribute tasks
if 'train' not in matches:
batchImg, batchTask, batchLabels \
= data.getBatch(params['batchSize'])
else:
batchImg, batchTask, batchLabels \
= data.getBatchSpecial(params['batchSize'], matches['train'],\
params['negFraction'])
# forward pass
team.forward(Variable(batchImg), Variable(batchTask))
# backward pass
batchReward = team.backward(optimizer, batchLabels, epoch)
# take a step by optimizer
optimizer.step()
#--------------------------------------------------------------------------
# switch to evaluate
team.evaluate()
def runMAMLtrain(runName='single'):
#------------------------------------------------------------------------
# setup experiment and dataset
#------------------------------------------------------------------------
data = Dataloader(options)
numInst = data.getInstCount()
params = data.params
# append options from options to params
for key, value in options.items():
params[key] = value
### checking and creating the folders and results files
#------------------------------------------------------------------------
# build agents, and setup optmizer
#------------------------------------------------------------------------
team = Team(params)
team.train()
#------------------------------------------------------------------------
# train agents
#------------------------------------------------------------------------
# begin training
### split tasks into train, valid and test, storing the split in data Object
task_list = [t for t in range(data.numPairTasks)]
num_train_tasks = 11
num_test_tasks = 1
train_tasks = task_list[:num_train_tasks]
test_tasks = task_list[num_train_tasks:]
data.seenTaskList = torch.LongTensor(train_tasks)
data.unseenTaskList = torch.LongTensor(test_tasks)
count = 0
savePath = 'models/' + MODELNAME + '/' + "Remember:" + str(
params['remember']) + "_AoutVocab=" + str(
params['aOutVocab']) + "_QoutVocab=" + str(
params['qOutVocab']) + "/" + "run" + str(runName)
makeDirs(savePath)
best_results = load_best_results(MODELNAME, runName, params)
matches = {}
accuracy = {}
matches_unseen = {}
accuracy_unseen = {}
bestAccuracy = 0
for param in team.aBot.parameters():
param.requires_grad = False
for param in team.qBot.parameters():
param.requires_grad = False
for episode in range(params['num_episodes']):
totalReward = 0
sampled_tasks = sample(train_tasks, params['num_tasks_per_episode'])
stored_abot_params = []
stored_qbot_params = []
for task in sampled_tasks:
## create copy of team for inner update, and inner optimizers
batch_task_list = torch.LongTensor([
task for i in range(params['batchSize'])
]) ### all tasks should be the same in an iteration with maml
copied_team = deepcopy(team)
for param in copied_team.aBot.parameters():
param.requires_grad = True
for param in copied_team.qBot.parameters():
param.requires_grad = True
optimizer_inner = optim.Adam([{'params': copied_team.aBot.parameters(), \
'lr':params['learningRate_inner']},\
{'params': copied_team.qBot.parameters(), \
'lr':params['learningRate_inner']}])
# get double attribute tasks
if 'train' not in matches:
batchImg, batchTask, batchLabels \
= data.getBatch(params['batchSize'], tasks=batch_task_list)
else:
batchImg, batchTask, batchLabels \
= data.getBatchSpecial(params['batchSize'], matches['train'],\
params['negFraction'], tasks=batch_task_list)
for inner_step in range(params['inner_steps'] - 1):
# forward pass
copied_team.forward(Variable(batchImg), Variable(batchTask))
# backward pass
batchReward = copied_team.backward(optimizer_inner,
batchLabels, episode)
# take a step by optimizer
optimizer_inner.step()
optimizer_inner.zero_grad()
#--------------------------------------------------------------------------
# switch to evaluate
## last inner step grads will be transferred to the main model update
## sampling query set
if 'train' not in matches:
batchImg, batchTask, batchLabels \
= data.getBatch(params['batchSize'], tasks=batch_task_list)
else:
batchImg, batchTask, batchLabels \
= data.getBatchSpecial(params['batchSize'], matches['train'],\
params['negFraction'], tasks=batch_task_list)
# forward pass
copied_team.forward(Variable(batchImg), Variable(batchTask))
#totalReward += copied_team.totalReward
# backward pass
batchReward = copied_team.backward(optimizer_inner, batchLabels,
episode)
## storing inner gradients
stored_abot_params.append(copied_team.aBot.parameters())
stored_qbot_params.append(copied_team.qBot.parameters())
## get the stored gradients and update the original model
for stored_abot_param_list in stored_abot_params:
ABotParamList = [p for p in team.aBot.parameters()]
for paramInd, param in enumerate(stored_abot_param_list):
ABotParamList[paramInd] -= params['learningRate'] * param.grad
for stored_qbot_param_list in stored_qbot_params:
QBotParamList = [p for p in team.qBot.parameters()]
for paramInd, param in enumerate(stored_qbot_param_list):
QBotParamList[paramInd] -= params['learningRate'] * param.grad
## reducing lr
if episode + 1 % 1000 == 0:
params['learningRate'] /= 5
params['learningRate_inner'] /= 5
### checking after certain episodes
if episode % params['validation_frequency'] == 0:
team.evaluate()
best_avg_valid_acc = 0.5 * best_results[
"valid_seen_domains"] + 0.5 * best_results[
"valid_unseen_domains"]
for dtype in ['train', 'valid', 'test']:
# get the entire batch
img, task, labels = data.getCompleteData(dtype)
# evaluate on the train dataset, using greedy policy
guess, _, _ = team.forward(Variable(img), Variable(task))
# compute accuracy for color, shape, and both
firstMatch = guess[0].data == labels[:, 0].long()
secondMatch = guess[1].data == labels[:, 1].long()
matches[dtype] = firstMatch & secondMatch
accuracy[dtype] = 100*torch.sum(matches[dtype])\
/float(matches[dtype].size(0))
### chack acc on unseen domains
for dtype in ['train', 'valid', 'test']:
# get the entire batch
img, task, labels = data.getCompleteData(dtype, 'unseen')
# evaluate on the train dataset, using greedy policy
guess, _, _ = team.forward(Variable(img), Variable(task))
# compute accuracy for color, shape, and both
firstMatch = guess[0].data == labels[:, 0].long()
secondMatch = guess[1].data == labels[:, 1].long()
matches_unseen[dtype] = firstMatch & secondMatch
accuracy_unseen[dtype] = 100*torch.sum(matches_unseen[dtype])\
/float(matches_unseen[dtype].size(0))
time = strftime("%a, %d %b %Y %X", gmtime())
avg_valid_acc = 0.5 * accuracy['valid'].item(
) + 0.5 * accuracy_unseen['valid'].item()
print('[%s][Episode: %.2f][Query set total reward: %.4f][SEEN TASK--Tr acc: %.2f Valid acc: %.2f Test acc: %.2f][UNSEEN TASK--Tr acc: %.2f V acc: %.2f Tst acc: %.2f]' % \
(time, episode, totalReward,\
accuracy['train'], accuracy['valid'], accuracy['test'], accuracy_unseen['train'], accuracy_unseen['valid'], accuracy_unseen['test']))
# save model and res if validation accuracy is the best
if avg_valid_acc >= best_avg_valid_acc:
saveModel(savePath, team, optimizer_inner, params)
best_results = {
"train_seen_domains": accuracy['train'].item(),
"valid_seen_domains": accuracy['valid'].item(),
"test_seen_domains": accuracy['test'].item(),
"train_unseen_domains": accuracy_unseen['train'].item(),
"valid_unseen_domains": accuracy_unseen['valid'].item(),
"test_unseen_domains": accuracy_unseen['test'].item()
}
store_results(best_results, MODELNAME, runName, params)
best_avg_valid_acc = 0.5 * best_results[
"valid_seen_domains"] + 0.5 * best_results[
"valid_unseen_domains"]
# break if train accuracy reaches 100%
if accuracy['train'] == 100: break
# switch to train
team.train()
### save final model
##saveModel(savePath, team, optimizer_inner, params)
print("run finished, returning best results")
return best_results
numIterPerEpoch = int(np.ceil(numInst['train'] / params['batchSize']))
numIterPerEpoch = max(1, numIterPerEpoch)
count = 0
savePath = 'models/tasks_inter_%dH_%.4flr_%r_%d_%d.pickle' %\
(params['hiddenSize'], params['learningRate'], params['remember'],\
options['aOutVocab'], options['qOutVocab'])
matches = {}
accuracy = {}
bestAccuracy = 0
for iterId in range(params['numEpochs'] * numIterPerEpoch):
epoch = float(iterId) / numIterPerEpoch
# get double attribute tasks
if 'train' not in matches:
batchImg, batchTask, batchLabels = data.getBatch(params['batchSize'])
else:
batchImg, batchTask, batchLabels = data.getBatchSpecial(
params['batchSize'], matches['train'], params['negFraction'])
optimizer.zero_grad()
# forward pass
team.forward(Variable(batchImg), Variable(batchTask))
# backward pass
loss = team.backward(optimizer, batchLabels, epoch)
# take a step by optimizer
optimizer.step()
#--------------------------------------------------------------------------
# switch to evaluate
team.evaluate()
with torch.no_grad():
def runOriginalModelTrain(runName = 'single' ):
#------------------------------------------------------------------------
# setup experiment and dataset
#------------------------------------------------------------------------
data = Dataloader(options)
numInst = data.getInstCount()
### split tasks into train, valid and test, storing the split in data Object
task_list = [t for t in range(data.numPairTasks)]
num_train_tasks = 11
num_test_tasks = 1
train_tasks = task_list[:num_train_tasks]
test_tasks = task_list[num_train_tasks:]
data.seenTaskList = torch.LongTensor(train_tasks)
data.unseenTaskList = torch.LongTensor(test_tasks)
params = data.params
# append options from options to params
for key, value in options.items():
params[key] = value
### checking and creating the folders and results files
#------------------------------------------------------------------------
# build agents, and setup optmizer
#------------------------------------------------------------------------
team = Team(params)
team.train()
optimizer = optim.Adam([{'params': team.aBot.parameters(), \
'lr':params['learningRate']},\
{'params': team.qBot.parameters(), \
'lr':params['learningRate']}])
#------------------------------------------------------------------------
# train agents
#------------------------------------------------------------------------
# begin training
numIterPerEpoch = int(np.ceil(numInst['train']/params['batchSize']))
numIterPerEpoch = max(1, numIterPerEpoch)
count = 0
savePath = 'models/' + MODELNAME + '/' + "Remember:" + str(params['remember']) + "_AoutVocab=" + str(params['aOutVocab']) + "_QoutVocab="+ str(params['qOutVocab']) + "/" + "run"+str(runName)
makeDirs(savePath)
best_results = load_best_results(MODELNAME, runName, params)
matches = {}
accuracy = {}
matches_unseen = {}
accuracy_unseen = {}
bestAccuracy = 0
for iterId in range(params['numEpochs'] * numIterPerEpoch):
epoch = float(iterId)/numIterPerEpoch
# get double attribute tasks
if 'train' not in matches:
batchImg, batchTask, batchLabels \
= data.getBatch(params['batchSize'])
else:
batchImg, batchTask, batchLabels \
= data.getBatchSpecial(params['batchSize'], matches['train'],\
params['negFraction'])
# forward pass
team.train()
team.forward(Variable(batchImg), Variable(batchTask))
# backward pass
batchReward = team.backward(optimizer, batchLabels, epoch)
# take a step by optimizer
optimizer.step()
optimizer.zero_grad()
#--------------------------------------------------------------------------
## checking model performannce after certain iters
if iterId % params['validation_frequency'] == 0:
# switch to evaluate
team.evaluate()
best_avg_valid_acc = 0.5* best_results["valid_seen_domains"] + 0.5 * best_results["valid_unseen_domains"]
for dtype in ['train', 'valid', 'test']:
# get the entire batch
img, task, labels = data.getCompleteData(dtype)
# evaluate on the train dataset, using greedy policy
guess, _, _ = team.forward(Variable(img), Variable(task))
# compute accuracy for color, shape, and both
firstMatch = guess[0].data == labels[:, 0].long()
secondMatch = guess[1].data == labels[:, 1].long()
matches[dtype] = firstMatch & secondMatch
accuracy[dtype] = 100*torch.sum(matches[dtype])\
/float(matches[dtype].size(0))
### check acc on unseen domains
for dtype in ['train','valid', 'test']:
# get the entire batch
img, task, labels = data.getCompleteData(dtype, 'unseen')
# evaluate on the train dataset, using greedy policy
guess, _, _ = team.forward(Variable(img), Variable(task))
# compute accuracy for color, shape, and both
firstMatch = guess[0].data == labels[:, 0].long()
secondMatch = guess[1].data == labels[:, 1].long()
matches_unseen[dtype] = firstMatch & secondMatch
accuracy_unseen[dtype] = 100*torch.sum(matches_unseen[dtype])\
/float(matches_unseen[dtype].size(0))
avg_valid_acc = 0.5*accuracy['valid'].item() + 0.5*accuracy_unseen['valid'].item()
# save model and res if validation accuracy is the best
if avg_valid_acc >= best_avg_valid_acc:
saveModel(savePath, team, optimizer, params)
best_results = {
"train_seen_domains" : accuracy['train'].item(),
"valid_seen_domains" : accuracy['valid'].item(),
"test_seen_domains": accuracy['test'].item(),
"train_unseen_domains": accuracy_unseen['train'].item(),
"valid_unseen_domains": accuracy_unseen['valid'].item(),
"test_unseen_domains" : accuracy_unseen['test'].item(),
}
store_results(best_results, MODELNAME, runName, params)
best_avg_valid_acc = 0.5* best_results["valid_seen_domains"] + 0.5 * best_results["valid_unseen_domains"]
# break if train accuracy reaches 100%
if accuracy['train'] == 100: break
if iterId % 100 != 0: continue
time = strftime("%a, %d %b %Y %X", gmtime())
print('[%s][Iter: %d][Ep: %.2f][R: %.4f][SEEN TASKS--Train: %.2f Valid: %.2f Test: %.2f][UNSEEN TASKS--Train: %.2f V: %.2f Tst: %.2f]' % \
(time, iterId, epoch, team.totalReward,\
accuracy['train'], accuracy['valid'], accuracy['test'], accuracy_unseen['train'], accuracy_unseen['valid'],accuracy_unseen['test'],))
##saveModel(savePath, team, optimizer, params)
print("run finished, returning best results")
return best_results
