def do_test(loadPath):
print('Loading model from: %s' % loadPath)
with open(loadPath, 'r') as fileId:
loaded = pickle.load(fileId);
#------------------------------------------------------------------------
# build dataset, load agents
#------------------------------------------------------------------------
params = loaded['params'];
data = Dataloader(params);
team = Team(params);
team.loadModel(loaded);
team.evaluate();
#------------------------------------------------------------------------
# test agents
#------------------------------------------------------------------------
dtypes = ['train']
for dtype in dtypes:
# evaluate on the train dataset, using greedy policy
images, tasks, labels = data.getCompleteData(dtype);
# forward pass
preds, _, talk, talk_list = team.forward(Variable(images), Variable(tasks), True);
options = dict()
options['qOutVocab'] = 3
options['aOutVocab'] = 4
m1,m2,ic1,ic2,h1,h2 = all_metrics(team, preds, talk_list, options)
# compute accuracy for first, second and both attributes
firstMatch = preds[0].data == labels[:, 0].long();
secondMatch = preds[1].data == labels[:, 1].long();
matches = firstMatch & secondMatch;
atleastOne = firstMatch | secondMatch;
# compute accuracy
firstAcc = 100 * torch.mean(firstMatch.float());
secondAcc = 100 * torch.mean(secondMatch.float());
atleastAcc = 100 * torch.mean(atleastOne.float());
accuracy = 100 * torch.mean(matches.float());
print('\nOverall accuracy [%s]: %.2f (f: %.2f s: %.2f, atleast: %.2f)'\
% (dtype, accuracy, firstAcc, secondAcc, atleastAcc));
# pretty print
talk = data.reformatTalk(talk, preds, images, tasks, labels);
if 'final' in loadPath:
savePath = loadPath.replace('final', 'chatlog-'+dtype);
elif 'inter' in loadPath:
savePath = loadPath.replace('inter', 'chatlog-'+dtype);
savePath = savePath.replace('pickle', 'json');
print('Saving conversations: %s' % savePath)
with open(savePath, 'w') as fileId: json.dump(talk, fileId);
saveResultPage(savePath);
res1 = accuracy, firstAcc, secondAcc, atleastAcc
res2 = m1,m2,ic1,ic2,h1,h2
return res1, res2
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()
for dtype in ['train', '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))
# switch to train
team.train()
# break if train accuracy reaches 100%
if accuracy['train'] == 100: break
# save for every 5k epochs
probs_c = F.softmax(logits_c, dim=0).data.numpy()
cic = calc_cic(p_a_given_do_c[ag], probs_c, env.n_comm, env.n_acts)
cics[ag].append(cic)
return cics
if __name__ == '__main__':
loadPath = sys.argv[1]
print('Loading model from: %s' % loadPath)
with open(loadPath, 'r') as fileId:
loaded = pickle.load(fileId)
params = loaded['params']
data = Dataloader(params)
team = Team(params)
team.loadModel(loaded)
team.evaluate()
team.setOverhear(False)
team.setOverhearTask(False)
for dtype in ['train', 'test']:
print('%s metrics' % dtype)
images, tasks, labels = data.getCompleteData(dtype)
# forward pass
preds1,preds2,_,_,talk1,talk2 = team.forward(Variable(images),\
Variable(tasks), Variable(images), Variable(tasks), True)
all_metrics(team, preds1, preds2, talk1, talk2, params)
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
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