def create_tracker(pos, current_tracker):
positions = utils.tracker_positions(next_frame, pos)
n_tracker = utils.Tracker(positions, current_tracker.index,
current_tracker.tracking)
if not n_tracker.noise():
new_trackers.append(n_tracker)
return True
return False
def main():
if len(sys.argv) > 1:
name = ' '.join(sys.argv[1:])
else:
from datetime import datetime
name = datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
target_name = os.path.join('logs', '{}.pth'.format(name))
print('will save to {}'.format(target_name))
cudnn.benchmark = True
# train_loader = data.get_loader(config.train_path, train=True)
test_loader = data.get_loader(config.test_path, test=True)
cap_vcb = test_loader.dataset.token_to_index
hash_vcb = test_loader.dataset.answer_to_index
inv_hash_dict = {v: k for k, v in hash_vcb.items()}
inv_cap_dict = {v: k for k, v in cap_vcb.items()}
net = model.Net(test_loader.dataset.num_tokens[0],
test_loader.dataset.num_tokens[1], [], []).to(device)
# net = model.Net(train_loader.dataset.num_tokens[0],train_loader.dataset.num_tokens[1]).to(device)
# optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad])
# print(torch.load('logs/' + args.model_path)['weights'])
net.load_state_dict(torch.load('logs/' + args.model_path)['weights'])
tracker = utils.Tracker()
# for k,v in vars(config).items():
# print(k)
# sdfsd
#BRING THIS BACK
# criterion = nn.CrossEntropyLoss(ignore_index = PAD_IDX)
criterion = nn.CrossEntropyLoss(
ignore_index=test_loader.dataset.answer_to_index['<pad>'])
config_as_dict = {
k: v
for k, v in vars(config).items()
if not k.startswith('__') and not k.startswith('os')
and not k.startswith('expanduser') and not k.startswith('platform')
}
r = run(net,
test_loader,
tracker,
criterion,
cap_vcb,
hash_vcb,
train=False,
prefix='test',
epoch=0)
with open('output/hashtags.csv', 'w') as f:
for key in r[0].keys():
f.write("%s,%s\n" % (key, r[0][key]))
with open('output/captions.csv', 'w') as f:
for key in r[1].keys():
f.write("%s,%s\n" % (key, r[1][key]))
with open('output/predictions.csv', 'w') as f:
for key in r[2].keys():
f.write("%s,%s\n" % (key, r[2][key]))
def main(name=None):
print("running on", "cuda:0" if torch.cuda.is_available() else "cpu")
if len(sys.argv) > 1:
name = ' '.join(sys.argv[1:])
else:
from datetime import datetime
if name is None:
name = datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
else:
name = name + datetime.now().strftime("-%Y-%m-%d_%H:%M:%S")
target_name = os.path.join('logs_big', '{}.pth'.format(name))
print('will save to {}'.format(target_name))
cudnn.benchmark = True
train_loader = data.get_loader(train=True)
val_loader = data.get_loader(val=True)
config_as_dict = {
k: v
for k, v in vars(config).items() if not k.startswith('__')
}
net = nn.DataParallel(Net(train_loader.dataset.num_tokens)).cuda()
optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad],
weight_decay=config_as_dict["weight_decay"])
tracker = utils.Tracker()
for i in range(config.epochs):
_ = run(net,
train_loader,
optimizer,
tracker,
train=True,
prefix='train',
epoch=i)
r = run(net,
val_loader,
optimizer,
tracker,
train=False,
prefix='val',
epoch=i)
results = {
'name': name,
'tracker': tracker.to_dict(),
'config': config_as_dict,
'weights': net.state_dict(),
'eval': {
'answers': r[0],
'accuracies': r[1],
'idx': r[2],
},
'vocab': train_loader.dataset.vocab,
}
torch.save(results, target_name)
def main():
if len(sys.argv) > 1:
name = ' '.join(sys.argv[1:])
else:
from datetime import datetime
name = datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
target_name = os.path.join('logs', '{}.pth'.format(name))
print('will save to {}'.format(target_name))
cudnn.benchmark = True
train_loader = data.get_loader(train=True)
val_loader = data.get_loader(val=True)
with open('embedding/word_embedding.p', "rb") as f:
embedding_model = cPickle.load(f)
net = model.Net(embedding_model).to(device)
# net = model.Net(train_loader.dataset.num_tokens).to(device)
net = nn.DataParallel(net)
optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad])
tracker = utils.Tracker()
config_as_dict = {
k: v
for k, v in vars(config).items()
if (not k.startswith('__')) and (type(v) is not ModuleType)
}
for i in range(config.epochs):
_ = run(net,
train_loader,
optimizer,
tracker,
train=True,
prefix='train',
epoch=i)
r = run(net,
val_loader,
optimizer,
tracker,
train=False,
prefix='val',
epoch=i)
results = {
'name': name,
'tracker': tracker.to_dict(),
'config': config_as_dict,
'weights': net.state_dict(),
'eval': {
'answers': r[0],
'accuracies': r[1],
'idx': r[2],
},
'vocab': train_loader.dataset.vocab,
}
torch.save(results, target_name)
def main():
if len(sys.argv) > 1:
name = ' '.join(sys.argv[1:])
else:
from datetime import datetime
name = datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
target_name = os.path.join('logs', '{}.pth'.format(name))
print('will save to {}'.format(target_name))
cudnn.benchmark = True
print("Loading training set")
train_loader = data.get_loader(train=True)
print("Loading testing set:")
val_loader = data.get_loader(val=True)
net = nn.DataParallel(model.Net(train_loader.dataset.num_tokens)).cuda()
optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad])
tracker = utils.Tracker()
config_as_dict = {
k: v
for k, v in vars(config).items() if not k.startswith('__')
}
print("Training....")
for i in range(config.epochs):
_ = run(net,
train_loader,
optimizer,
tracker,
train=True,
prefix='train',
epoch=i)
r = run(net,
val_loader,
optimizer,
tracker,
train=False,
prefix='val',
epoch=i)
results = {
'name': name,
'tracker': tracker.to_dict(),
'config': config_as_dict,
'weights': net.state_dict(),
'eval': {
'answers': r[0],
'accuracies': r[1],
'idx': r[2],
},
'vocab': train_loader.dataset.vocab,
}
torch.save(results, target_name)
def main():
if len(sys.argv) > 1:
name = ' '.join(sys.argv[1:])
else:
from datetime import datetime
name = datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
target_name = os.path.join('logs', '{}.pth'.format(name))
model_name = os.path.join('logs', '{}_model.pth'.format(name))
print('will save to {}'.format(target_name))
cudnn.benchmark = True
train_loader = data.get_loader(train=True)
val_loader = data.get_loader(val=True)
net = nn.DataParallel(model.Net(train_loader.dataset.num_tokens)).cuda()
optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad])
tracker = utils.Tracker()
config_as_dict = {k: v for k, v in vars(config).items() if not k.startswith('__')}
for i in range(config.epochs):
_ = run(net, train_loader, optimizer, tracker, train=True, prefix='train', epoch=i)
r = run(net, val_loader, optimizer, tracker, train=False, prefix='val', epoch=i)
results = {
'name': name,
'epoch': i,
'tracker': tracker.to_dict(),
'config': config_as_dict,
'weights': net.state_dict(),
'eval': {
'answers': r[0],
'accuracies': r[1],
'idx': r[2],
},
'optimizer' : optimizer.state_dict(),
'vocab': train_loader.dataset.vocab,
}
torch.save(results, target_name)
# save best model so far
val_acc = torch.FloatTensor(tracker.to_dict()['val_acc'])
val_acc = val_acc.mean(dim=1).numpy()
is_best = True
for j in range(len(val_acc) - 1):
if val_acc[-1] <= val_acc[j]:
is_best = False
if is_best:
save_model = {
'epoch': i,
'weights': net.state_dict()
}
torch.save(save_model, model_name)
def main():
if len(sys.argv) > 1: # 外界获得的参数列表：['/home/users2/xcm09/VQA/train.py']
name = ' '.join(sys.argv[1:])
else:
from datetime import datetime
name = datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
target_name = os.path.join('logs', '{}.pth'.format(name))
print('模型 will save to {}'.format(target_name))
cudnn.benchmark = True
train_loader = data.get_loader(train=True)
val_loader = data.get_loader(val=True)
net = model.Net(train_loader.dataset.num_tokens).cuda() # 15193
# net = nn.DataParallel(model.Net(train_loader.dataset.num_tokens), device_ids=config.device_ids).cuda()
optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad])
tracker = utils.Tracker()
config_as_dict = {
k: v
for k, v in vars(config).items() if not k.startswith('__')
}
for i in range(config.epochs):
a = time()
_ = run(net,
train_loader,
optimizer,
tracker,
train=True,
prefix='train',
epoch=i)
r = run(net,
val_loader,
optimizer,
tracker,
train=False,
prefix='val',
epoch=i)
results = {
'name': name,
'tracker': tracker.to_dict(),
'config': config_as_dict,
'weights': net.state_dict(),
'eval': {
'answers': r[0],
'accuracies': r[1],
'idx': r[2],
},
'vocab': train_loader.dataset.vocab,
}
torch.save(results, target_name)
b = time() - a
print('该epoch耗时%d:%d' % (b // 60, b % 60))
def main():
start_time = datetime.datetime.now()
start_time_str = start_time.strftime("%Y-%m-%d_%H-%M-%S")
progress_file = start_time_str + '_progress.csv'
cudnn.benchmark = True
train_loader = data.get_loader(train=True)
val_loader = data.get_loader(val=True)
net = nn.DataParallel(model.Net(train_loader.dataset.num_tokens)).cuda()
optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad])
tracker = utils.Tracker()
config_as_dict = {
k: v
for k, v in vars(config).items() if not k.startswith('__')
}
train_loss_list = []
train_acc_list = []
val_loss_list = []
val_acc_list = []
max_acc = 0
for i in range(config.epochs):
print('epoch %d' % i)
print('train')
train_loss, train_acc = run(net,
train_loader,
optimizer,
tracker,
train=True,
prefix='train',
epoch=i)
print('validation')
val_loss, val_acc = run(net,
val_loader,
optimizer,
tracker,
train=False,
prefix='val',
epoch=i)
train_loss_list.append(train_loss)
train_acc_list.append(train_acc)
val_loss_list.append(val_loss)
val_acc_list.append(val_acc)
write_progress(train_acc_list, train_loss_list, val_acc_list,
val_loss_list, progress_file)
if val_acc > max_acc and val_acc > 0.45:
print('model saved')
torch.save(net.state_dict(), start_time_str + '_best_model.pkl')
max_acc = val_acc
def main():
assert len(sys.argv) == 3
log = torch.load(sys.argv[2], map_location=torch.device('cpu'))
num_tokens = len(log['vocab']['question']) + 1
answer_map = {v: k for k, v in log['vocab']['answer'].items()}
test_loader = data.get_loader(test=True)
if sys.argv[1] == 'baseline':
import model_baseline as model
elif sys.argv[1] == 'modified_attention':
import model_modified_attention as model
elif sys.argv[1] == 'big':
import model_big as model
elif sys.argv[1] == 'combined':
import model_combined as model
elif sys.argv[1] == 'naive':
import model_degenerate as model
test_loader = data.get_loader(test=True, include_original_images=True)
else:
print("Re-enter the name of model!")
net = nn.DataParallel(model.Net(num_tokens)).cuda()
net.load_state_dict(log['weights'])
optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad],
weight_decay=config.weight_decay)
tracker = utils.Tracker()
results = model.run(net,
test_loader,
optimizer,
tracker,
train=False,
prefix='val',
epoch=-1)
anss, accs, idxs = results
answers = [answer_map[ans.item()] for ans in anss]
image_names = [f"VizWiz_test_{idx:08d}.jpg" for idx in idxs]
results = [{
"image": image_name,
"answer": ans
} for image_name, ans in zip(image_names, answers)]
assert sum(accs) == 0
log_name = os.path.basename(sys.argv[2])
log_name = log_name[:log_name.index('-')]
with open(os.path.join("test_results", f"{log_name}.json"), 'w') as fd:
json.dump(results, fd)
def main():
global total_iterations
total_iterations = 1
if len(sys.argv) > 1:
name = 'lang_attacker_' + (' '.join(sys.argv[1:]))
else:
from datetime import datetime
name = datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
target_name = os.path.join('logs', 'lang_attacker_{}.pth'.format(name))
print('will save to {}'.format(target_name))
cudnn.benchmark = True
print("Initialize Data Loaders")
train_loader = data.get_loader(train=True, batch_size=config.batch_size)
val_loader = data.get_loader(val=True, batch_size=config.batch_size)
#net = nn.DataParallel(model.Net(train_loader.dataset.num_tokens)).cuda()
# Define and loadup the models
print("Initialize VQA model")
vqa_model = model.VQANet()
# Get question and vocab answer
vocab = vqa_model.get_vocab()
# Define attacker
#print("Load Attacker model")
#Uncomment this for AttendAndAttackNet
#attacker = Attacker(vqa_model)
#Uncomment this for Carlini
#attacker = CarliniAttacker(vqa_model)
#optimizer = optim.Adam([p for p in attacker.attack_model.parameters() if p.requires_grad])
#scheduler = ReduceLROnPlateau(optimizer, 'min')
tracker = utils.Tracker()
config_as_dict = {k: v for k, v in vars(config).items() if not k.startswith('__')}
print("Begin Inference")
eval_after_epochs = 1 #Run eval after these many epochs
for i in range(1): #Only 1 epoch needed for inference. Keep this to later generalize to training to protect against attacks
#Run a train epoch
#acc = run(vqa_model, train_loader, tracker, train=True, prefix='train', epoch=i)
#Run inference
acc = run(vqa_model, val_loader, tracker, train=False, prefix='val', epoch=i)
print("Epoch " + str(i) +" : Inference Results: Accuracy: "+ str(acc))
'''
def main():
from datetime import datetime
# this has been changed to run jupyter
#
# non jupyter ##############################################################
if len(sys.argv) > 1:
name = ' '.join(sys.argv[1:])
else:
name = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
############################################################################
# remove line below if not running on jupyter
name = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
target_name = os.path.join('logs', '{}.pth'.format(name))
print('will save to {}'.format(target_name))
cudnn.benchmark = True
train_loader = data.get_loader(train=True)
val_loader = data.get_loader(val=True)
net = nn.DataParallel(modelNoAttention.Net(train_loader.dataset.num_tokens)).cuda() #change made here
optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad], weight_decay=0.01)
tracker = utils.Tracker()
config_as_dict = {k: v for k, v in vars(config).items() if not k.startswith('__')}
for i in range(config.epochs):
_ = run(net, train_loader, optimizer, tracker, train=True, prefix='train', epoch=i)
r = run(net, val_loader, optimizer, tracker, train=False, prefix='val', epoch=i)
results = {
'name': name,
'tracker': tracker.to_dict(),
'config': config_as_dict,
'weights': net.state_dict(),
'eval': {
'answers': r[0],
'accuracies': r[1],
'idx': r[2],
},
'vocab': train_loader.dataset.vocab,
}
torch.save(results, target_name)
def main():
from datetime import datetime
name = datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
target_name = os.path.join('logs_is_color', '{}.pth'.format(name))
print('will save to {}'.format(target_name))
train_loader = data.get_loader(train=True, check_pertains_to_color=True)
val_loader = data.get_loader(val=True, check_pertains_to_color=True)
net = nn.DataParallel(ColorNet(train_loader.dataset.num_tokens)).cuda()
tracker = utils.Tracker()
optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad],
weight_decay=0.01)
config_as_dict = {
k: v
for k, v in vars(config).items() if not k.startswith('__')
}
for i in range(config.epochs):
_ = run(net,
train_loader,
optimizer,
tracker,
train=True,
prefix='train',
epoch=i)
r = run(net,
val_loader,
optimizer,
tracker,
train=False,
prefix='val',
epoch=i)
results = {
'name': name,
'tracker': tracker.to_dict(),
'config': config_as_dict,
'weights': net.state_dict(),
'eval': {
'answers': r[0],
'accuracies': r[1],
'idx': r[2],
},
'vocab': train_loader.dataset.vocab,
}
torch.save(results, target_name)
def test():
log = torch.load('results/baseline.pt')
tokens = len(log['vocab']['question']) + 1
net = torch.nn.DataParallel(model.Net(tokens))
net.load_state_dict(log['weights'])
net.cuda()
print('model loaded')
train_loader = data.get_loader(train=True)
val_loader = data.get_loader(val=True)
tracker = utils.Tracker()
r = run(net, val_loader, None, tracker, train=False, prefix='val')
print(r[1])
def main():
print("running on", "cuda:0" if torch.cuda.is_available() else "cpu")
if len(sys.argv) > 1:
name = ' '.join(sys.argv[1:])
else:
from datetime import datetime
name = datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
target_name = os.path.join('logs_karl', '{}.pth'.format(name))
print('will save to {}'.format(target_name))
cudnn.benchmark = True
train_loader = data.get_loader(train=True)
val_loader = data.get_loader(val=True)
# net = nn.DataParallel(model_modified_attention.Net(train_loader.dataset.num_tokens)).cuda()
net = model_modified_attention.Net(train_loader.dataset.num_tokens)
print(net)
optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad])
for name, layer in net.named_modules():
if isinstance(layer, torch.nn.Conv2d):
print(name, layer)
net.attention.register_forward_hook(get_activation('attention'))
tracker = utils.Tracker()
config_as_dict = {k: v for k, v in vars(config).items() if not k.startswith('__')}
for i in range(1):
_ = run(net, train_loader, optimizer, tracker, train=True, prefix='train', epoch=i)
r = run(net, val_loader, optimizer, tracker, train=False, prefix='val', epoch=i)
results = {
'name': name,
'tracker': tracker.to_dict(),
'config': config_as_dict,
'weights': net.state_dict(),
'eval': {
'answers': r[0],
'accuracies': r[1],
'idx': r[2],
},
'vocab': train_loader.dataset.vocab,
}
torch.save(results, target_name)
def evaluate_hw3():
# all data files should be inside "coco" folder in the project directory
preprocess_images.run(is_evaluate=True)
preprocess_vocab.run()
val_loader = data.get_loader(val=True)
net = nn.DataParallel(model.Net(val_loader.dataset.num_tokens)).cuda()
net.load_state_dict(
torch.load('model.pkl', map_location=lambda storage, loc: storage))
optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad])
tracker = utils.Tracker()
answers, accuracies, idx = start(net,
val_loader,
optimizer,
tracker,
train=False,
prefix='val')
acc = calc_accuracy(accuracies)
print('%.2f' % acc)
def evaluate_hw3():
print('preprocessing images')
preprocess_images(train=False)
print('preprocessing text')
preprocess_text()
print('loading data')
val_loader = data.get_loader(val=True)
net = nn.DataParallel(model.Net(config.default_num_tokens)).cuda()
net.load_state_dict(
torch.load('model.pkl', map_location=lambda storage, loc: storage))
net = to_gpu(net)
optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad])
tracker = utils.Tracker()
print('runnning validation')
val_loss, val_acc = run(net,
val_loader,
optimizer,
tracker,
train=False,
prefix='val',
epoch=0)
print('validation acc: %.4f' % val_acc)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('name', nargs='*')
parser.add_argument('--eval', dest='eval_only', action='store_true')
parser.add_argument('--test', action='store_true')
parser.add_argument('--trainval', action='store_true')
parser.add_argument('--resume', nargs='*')
parser.add_argument('--describe',
type=str,
default='describe your setting')
args = parser.parse_args()
print('-' * 50)
print(args)
config.print_param()
# set mannual seed
torch.manual_seed(config.seed)
torch.cuda.manual_seed(config.seed)
if args.test:
args.eval_only = True
src = open(config.model_type + '_model.py').read()
if args.name:
name = ' '.join(args.name)
else:
from datetime import datetime
name = datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
target_name = os.path.join('logs', '{}.pth'.format(name))
if not args.test:
# target_name won't be used in test mode
print('will save to {}'.format(target_name))
if args.resume:
logs = torch.load(' '.join(args.resume))
# hacky way to tell the VQA classes that they should use the vocab without passing more params around
data.preloaded_vocab = logs['vocab']
cudnn.benchmark = True
if args.trainval:
train_loader = data.get_loader(trainval=True)
elif not args.eval_only:
train_loader = data.get_loader(train=True)
if args.trainval:
pass # since we use the entire train val splits, we don't need val during training
elif not args.test:
val_loader = data.get_loader(val=True)
else:
val_loader = data.get_loader(test=True)
question_keys = train_loader.dataset.vocab['question'].keys(
) if args.trainval else val_loader.dataset.vocab['question'].keys()
net = model.Net(question_keys)
net = nn.DataParallel(net).cuda() # Support multiple GPUS
select_optim = optim.Adamax if (config.optim_method
== 'Adamax') else optim.Adam
optimizer = select_optim([p for p in net.parameters() if p.requires_grad],
lr=config.initial_lr,
weight_decay=config.weight_decay)
scheduler = lr_scheduler.ExponentialLR(optimizer,
0.5**(1 / config.lr_halflife))
if args.resume:
net.module.load_state_dict(logs['weights'])
print(net)
tracker = utils.Tracker()
config_as_dict = {
k: v
for k, v in vars(config).items() if not k.startswith('__')
}
for i in range(config.epochs):
if not args.eval_only:
run(net,
train_loader,
optimizer,
scheduler,
tracker,
train=True,
prefix='train',
epoch=i)
if not args.trainval:
r = run(net,
val_loader,
optimizer,
scheduler,
tracker,
train=False,
prefix='val',
epoch=i,
has_answers=not args.test)
else:
r = [[-1], [-1], [-1]] # dummy results
if not args.test:
results = {
'name':
name,
'tracker':
tracker.to_dict(),
'config':
config_as_dict,
'weights':
net.module.state_dict(),
'eval': {
'answers': r[0],
'accuracies': r[1],
'idx': r[2],
},
'vocab':
val_loader.dataset.vocab
if not args.trainval else train_loader.dataset.vocab,
'src':
src,
}
torch.save(results, target_name)
else:
# in test mode, save a results file in the format accepted by the submission server
answer_index_to_string = {
a: s
for s, a in val_loader.dataset.answer_to_index.items()
}
results = []
for answer, index in zip(r[0], r[2]):
answer = answer_index_to_string[answer.item()]
qid = val_loader.dataset.question_ids[index]
entry = {
'question_id': qid,
'answer': answer,
}
results.append(entry)
with open(config.result_json_path, 'w') as fd:
json.dump(results, fd)
if args.eval_only:
break
def main():
parser = argparse.ArgumentParser()
parser.add_argument('name', nargs='*')
parser.add_argument('--eval', dest='eval_only', action='store_true')
parser.add_argument('--test', action='store_true')
parser.add_argument('--resume', nargs='*')
# parser.add_argument('--image_url', type = str, default='')
# parser.add_argument('--question_id', type = int)
# parser.add_argument('--embedding', default='kor2vec', type='str', help='embedding method')
args = parser.parse_args()
if args.test:
args.eval_only = True
# if args.image_
# if args.embedding == 'kor2vec':
# src = open('model_kor2vec.py').read()
# if args.embedding == '':
# src = open('model_original.py').read()
src = open('model.py').read()
if args.name:
name = ' '.join(args.name)
else:
from datetime import datetime
name = datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
target_name = os.path.join('logs', '{}.pth'.format(name))
# target_name = '/mnt/crawl/counting_logs/{}.pth'.format(name)
if not args.test:
# target_name won't be used in test mode
print('will save to {}'.format(target_name))
if args.resume:
logs = torch.load(' '.join(args.resume))
# hacky way to tell the VQA classes that they should use the vocab without passing more params around
data.preloaded_vocab = logs['vocab']
cudnn.benchmark = True
print('start loader...')
if not args.eval_only:
train_loader = data.get_loader(train=True)
if not args.test:
val_loader = data.get_loader(val=True)
else:
val_loader = data.get_loader(test=True)
print('start net / optimizer / scheduler...')
# model = nn.DataParallel(models.Model(config, train_loader.dataset.num_tokens)).cuda()
# if args.embedding == 'kor2vec':
# net = nn.DataParallel(model_kor2vec.Net(val_loader.dataset.num_tokens)).cuda()
# if args.embedding == '':
# if you want to use 2 gpus
# net = nn.DataParallel(model_original.Net(val_loader.dataset.num_tokens)).cuda()
net = nn.DataParallel(model.Net(val_loader.dataset.num_tokens)).cuda()
# if you want to use 1 gpus
# torch.cuda.set_device(0)
# net = model.Net(val_loader.dataset.num_tokens).cuda()
optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad],
lr=config.initial_lr)
scheduler = lr_scheduler.ExponentialLR(optimizer,
0.5**(1 / config.lr_halflife))
# epoch = config.epochs
if args.resume:
net.load_state_dict(logs['weights'])
# checkpoint = torch.load(logs)
# print("cp", checkpoint)
# model.load_state_dict(checkpoint['model_state_dict'])
# optimizer.load_state_dict(logs['optimizer_state_dict'])
# epoch = logs['epoch']
# loss = logs['loss']
# model.train()
tracker = utils.Tracker()
config_as_dict = {
k: v
for k, v in vars(config).items() if not k.startswith('__')
}
# if not args.test and not args.eval:
print('start training...')
for i in range(config.epochs):
if not args.eval_only:
print('train.. not args.eval_only')
print('start train!!!!...')
run(net,
train_loader,
optimizer,
scheduler,
tracker,
train=True,
prefix='train',
epoch=i)
print('start val!!!!...')
r = run(net,
val_loader,
optimizer,
scheduler,
tracker,
train=False,
prefix='val',
epoch=i,
has_answers=not args.test)
# print("r3", r[3])
if not args.test:
print('train.. if not args.test')
if i % 5 == 0:
now = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
save_name = '/mnt/backup/ran/vqa/vqa/save/ko100_{0}_{1}.pth'.format(
now, i) # 20191028기준 lr1이 메인
# target_name = os.path.join('logs', '{}.pth'.format(name))
results = {
'name': name,
'tracker': tracker.to_dict(),
'config': config_as_dict,
'weights': net.state_dict(),
'eval': {
'answers': r[0],
'accuracies': r[1],
'idx': r[2],
},
'vocab': val_loader.dataset.vocab,
'src': src,
'epoch': i,
# 'model_state_dict': net.state_dict(), #weight
'optimizer_state_dict':
optimizer.state_dict(), # optimizer weight
# 'loss': loss,
}
torch.save(results, save_name)
if i == 99:
now = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
save_name = '/mnt/crawl/counting_logs/eng_{0}_final.pth'.format(
now)
# target_name = os.path.join('logs', '{}.pth'.format(name))
results = {
'name': name,
'tracker': tracker.to_dict(),
'config': config_as_dict,
'weights': net.state_dict(),
'eval': {
'answers': r[0],
'accuracies': r[1],
'idx': r[2],
},
'vocab': val_loader.dataset.vocab,
'src': src,
}
torch.save(results, save_name)
else:
# in test mode, save a results file in the format accepted by the submission server
print('train.. else -> yes args.test')
# torch.load("")
answer_index_to_string = {
a: s
for s, a in val_loader.dataset.answer_to_index.items()
}
# with open('answer_index_to_string.txt', 'w') as f:
# json.dump(answer_index_to_string, f)
results = []
for answer, index in zip(r[0], r[2]): # r3
try:
answer = answer_index_to_string[answer.item()]
except KeyError:
continue
# answer = answer_index_to_string[answer.item()]
qid = val_loader.dataset.question_ids[index]
entry = {
'question_id': qid,
'answer': answer
# 'all_answer': rr
}
results.append(entry)
with open('results_test.json', 'w') as fd:
json.dump(results, fd)
if args.eval_only:
# else:
# in test mode, save a results file in the format accepted by the submission server
print('eval+pnp')
# torch.load("")
answer_index_to_string = {
a: s
for s, a in val_loader.dataset.answer_to_index.items()
}
# with open('answer_index_to_string.txt', 'w') as f:
# json.dump(answer_index_to_string, fd)
results = []
for answer, index in zip(r[0], r[2]):
try:
answer = answer_index_to_string[answer.item()]
except KeyError:
continue
qid = val_loader.dataset.question_ids[index]
entry = {
'question_id': qid,
'answer': answer,
# 'all_answer':rr
}
results.append(entry)
with open('results_test.json', 'w') as fd:
json.dump(results, fd)
break
def main():
parser = argparse.ArgumentParser()
parser.add_argument('name', nargs='*')
parser.add_argument('--eval', dest='eval_only', action='store_true')
parser.add_argument('--test', action='store_true')
parser.add_argument('--resume', nargs='*')
args = parser.parse_args()
if args.test:
args.eval_only = True
src = open('model.py').read()
if len(sys.argv) > 1:
name = ' '.join(args.name)
else:
from datetime import datetime
name = datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
target_name = os.path.join('logs', '{}.pth'.format(name))
if not args.test:
# target_name won't be used in test mode
print('will save to {}'.format(target_name))
cudnn.benchmark = True
if not args.eval_only:
train_loader = data.get_loader(train=True)
if not args.test:
val_loader = data.get_loader(val=True)
else:
val_loader = data.get_loader(test=True)
net = model.Net(val_loader.dataset.num_tokens).cuda()
optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad],
lr=config.initial_lr)
scheduler = lr_scheduler.ExponentialLR(optimizer,
0.5**(1 / config.lr_halflife))
if args.resume:
net.load_state_dict(torch.load(' '.join(args.resume))['weights'])
tracker = utils.Tracker()
config_as_dict = {
k: v
for k, v in vars(config).items() if not k.startswith('__')
}
for i in range(config.epochs):
if not args.eval_only:
run(net,
train_loader,
optimizer,
scheduler,
tracker,
train=True,
prefix='train',
epoch=i)
r = run(net,
val_loader,
optimizer,
scheduler,
tracker,
train=False,
prefix='val',
epoch=i,
has_answers=not args.test)
if not args.test:
results = {
'name': name,
'tracker': tracker.to_dict(),
'config': config_as_dict,
'weights': net.state_dict(),
'eval': {
'answers': r[0],
'accuracies': r[1],
'idx': r[2],
},
'vocab': val_loader.dataset.vocab,
'src': src,
}
torch.save(results, target_name)
else:
# in test mode, save a results file in the format accepted by the submission server
answer_index_to_string = {
a: s
for s, a in val_loader.dataset.answer_to_index.items()
}
results = []
for answer, index in zip(r[0], r[2]):
answer = answer_index_to_string[answer]
qid = val_loader.dataset.question_ids[index]
entry = {
'question_id': qid,
'answer': answer,
}
results.append(entry)
with open('results.json', 'w') as fd:
json.dump(results, fd)
if args.eval_only:
break
def main():
# set is you want to retrain
retrain = False
retrain_path = "logs/DropOut0"
if len(sys.argv) > 1:
name = ''.join(sys.argv[1:])
else:
from datetime import datetime
name = datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
target_name = os.path.join('logs', '{}.pth'.format(name))
print('will save to {}'.format(target_name))
cudnn.benchmark = True
train_loader = data.get_loader(train=True)
val_loader = data.get_loader(val=True)
if retrain:
print("Retraining from" + retrain_path)
log = torch.load(retrain_path + '.pth')
tokens = len(log['vocab']['question']) + 1
net = torch.nn.DataParallel(model.Net(tokens)).cuda()
net.load_state_dict(log['weights'])
else:
print("Training new net")
net = nn.DataParallel(model.Net(
train_loader.dataset.num_tokens)).cuda()
optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad])
tracker = utils.Tracker()
config_as_dict = {
k: v
for k, v in vars(config).items() if not k.startswith('__')
}
train_acc = []
train_loss = []
val_acc = []
for i in range(config.epochs):
accs, losses = run(net,
train_loader,
optimizer,
tracker,
train=True,
prefix='train',
epoch=i)
r = run(net,
val_loader,
optimizer,
tracker,
train=False,
prefix='val',
epoch=i)
train_acc.append(sum(accs) / len(accs))
train_loss.append(sum(losses) / len(losses))
val_acc.append(sum(r[1]) / len(r[1]))
results = {
'name': name,
'tracker': tracker.to_dict(),
'config': config_as_dict,
'weights': net.state_dict(),
'eval': {
'answers': r[0],
'accuracies': r[1],
'idx': r[2],
},
'vocab': train_loader.dataset.vocab,
}
torch.save(results, target_name)
with open(name + '_results.pkl',
'wb') as f: # Python 3: open(..., 'wb')
pickle.dump([train_acc, train_loss, val_acc], f)
def main():
# Load config yaml file
parser = argparse.ArgumentParser()
parser.add_argument('--path_config',
default='config/default.yaml',
type=str,
help='path to a yaml config file')
args = parser.parse_args()
if args.path_config is not None:
with open(args.path_config, 'r') as handle:
config = yaml.load(handle)
# generate log directory
dir_name = datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
path_log_dir = os.path.join(config['logs']['dir_logs'], dir_name)
if not os.path.exists(path_log_dir):
os.makedirs(path_log_dir)
print('Model logs will be saved in {}'.format(path_log_dir))
cudnn.benchmark = True
# Generate datasets and loaders
train_loader = vqa_dataset.get_loader(config, split='train')
val_loader = vqa_dataset.get_loader(config, split='val')
model = models.Model(config, train_loader.dataset.num_tokens).to(dev)
optimizer = torch.optim.Adam(
filter(lambda p: p.requires_grad, model.parameters()),
config['training']['lr'])
# Load model weights if necessary
if config['model']['pretrained_model'] is not None:
print("Loading Model from %s" % config['model']['pretrained_model'])
log = torch.load(config['model']['pretrained_model'])
dict_weights = log['weights']
model.load_state_dict(dict_weights)
tracker = utils.Tracker()
min_loss = 10
max_accuracy = 0
path_best_accuracy = os.path.join(path_log_dir, 'best_accuracy_log.pth')
path_best_loss = os.path.join(path_log_dir, 'best_loss_log.pth')
for i in range(config['training']['epochs']):
train(model,
train_loader,
optimizer,
tracker,
epoch=i,
split=config['training']['train_split'])
# If we are training on the train split (and not on train+val) we can evaluate on val
if config['training']['train_split'] == 'train':
eval_results = evaluate(model,
val_loader,
tracker,
epoch=i,
split='val')
# save all the information in the log file
log_data = {
'epoch': i,
'tracker': tracker.to_dict(),
'config': config,
'weights': model.state_dict(),
'eval_results': eval_results,
'vocabs': train_loader.dataset.vocabs,
}
# save logs for min validation loss and max validation accuracy
if eval_results['avg_loss'] < min_loss:
# torch.save(log_data, path_best_loss) # save model
min_loss = eval_results['avg_loss'] # update min loss value
if eval_results['avg_accuracy'] > max_accuracy:
# torch.save(log_data, path_best_accuracy) # save model
max_accuracy = eval_results[
'avg_accuracy'] # update max accuracy value
# Save final model
log_data = {
'tracker': tracker.to_dict(),
'config': config,
'weights': model.state_dict(),
'vocabs': train_loader.dataset.vocabs,
}
path_final_log = os.path.join(path_log_dir, 'final_log.pth')
torch.save(log_data, path_final_log)
def main():
print('-' * 50)
config.print_param()
# set mannual seed
torch.manual_seed(config.seed)
torch.cuda.manual_seed(config.seed)
train_loader = data.get_loader(train=True)
val_loader = data.get_loader(val=True)
cudnn.benchmark = True
question_keys = val_loader.dataset.vocab['question'].keys()
net = Net(question_keys)
net = nn.DataParallel(net).cuda() # Support multiple GPUS
select_optim = optim.Adamax if (config.optim_method
== 'Adamax') else optim.Adam
optimizer = select_optim([p for p in net.parameters() if p.requires_grad],
lr=config.initial_lr,
weight_decay=config.weight_decay)
scheduler = lr_scheduler.ExponentialLR(optimizer,
0.5**(1 / config.lr_halflife))
print(net)
train_errors_list = []
train_losses_list = []
val_errors_list = []
val_losses_list = []
tracker = utils.Tracker()
for i in range(1, config.epochs + 1):
# Train:
train_acc, train_loss = run(net,
train_loader,
optimizer,
scheduler,
tracker,
train=True,
prefix='train',
epoch=i)
# Val:
val_acc, val_loss = run(net,
val_loader,
optimizer,
scheduler,
tracker,
train=False,
prefix='val',
epoch=i)
train_errors_list.append(1 - train_acc)
train_losses_list.append(train_loss)
val_errors_list.append(1 - val_acc)
val_losses_list.append(val_loss)
torch.save(net.module.state_dict(), 'model.pkl')
sn.set()
ind = list(range(1, config.epochs + 1))
# Error
plt.plot(ind, train_errors_list, label='Train')
plt.plot(ind, val_errors_list, label='Validation')
plt.title('Error-rate during epochs')
plt.xlabel('Epochs')
plt.ylabel('Error-rate')
plt.legend()
# plt.show()
plt.savefig('error_rate.png')
plt.clf()
# Loss
plt.plot(ind, train_losses_list, label='Train')
plt.plot(ind, val_losses_list, label='Validation')
plt.title('Loss during epochs')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
# plt.show()
plt.savefig('loss_rate.png')
def main():
start_time = time.time()
cudnn.benchmark = True
train_dataset, train_loader = data.get_loader(train=True)
_, val_loader = data.get_loader(val=True)
#test_loader = data.get_loader(test=True)
if config.model_type == 'no_attn':
net = nn.DataParallel(model2.Net(
train_loader.dataset.num_tokens)).cuda()
target_name = os.path.join(config.model_path_no_attn)
elif config.model_type == 'with_attn':
net = nn.DataParallel(model.Net(
train_loader.dataset.num_tokens)).cuda()
target_name = os.path.join(config.model_path_show_ask_attend_answer)
elif 'finetuning_CNN_LSTM' in config.model_type:
#ipdb.set_trace()
net = nn.DataParallel(model2.Net(
train_loader.dataset.num_tokens)).cuda()
model_path = os.path.join(config.model_path_no_attn)
net.load_state_dict(
torch.load(model_path)["weights"]
) ## SO LOAD THE MODEL HERE- WE WANT TO START FINETUNING FROM THE BEST WE HAVE
target_name = os.path.join(
config.trained_model_save_folder) # so this will store the models
os.makedirs(target_name, exist_ok=True)
elif 'data_aug_CNN_LSTM' in config.model_type:
#ipdb.set_trace()
net = nn.DataParallel(model2.Net(
train_loader.dataset.num_tokens)).cuda()
target_name = os.path.join(
config.trained_model_save_folder) # so this will store the models
os.makedirs(target_name, exist_ok=True)
elif 'data_aug_SAAA' in config.model_type:
#ipdb.set_trace()
net = nn.DataParallel(model.Net(
train_loader.dataset.num_tokens)).cuda()
target_name = os.path.join(
config.trained_model_save_folder) # so this will store the models
os.makedirs(target_name, exist_ok=True)
elif 'finetuning_SAAA' in config.model_type:
net = nn.DataParallel(model.Net(
train_loader.dataset.num_tokens)).cuda()
model_path = os.path.join(config.model_path_show_ask_attend_answer)
net.load_state_dict(
torch.load(model_path)["weights"]
) ## SO LOAD THE MODEL HERE- WE WANT TO START FINETUNING FROM THE BEST WE HAVE
target_name = os.path.join(
config.trained_model_save_folder) # so this will store the models
os.makedirs(target_name, exist_ok=True)
# os.makedirs(target_name, exist_ok=True)
print('will save to {}'.format(target_name))
optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad])
tracker = utils.Tracker()
config_as_dict = {
k: v
for k, v in vars(config).items() if not k.startswith('__')
}
for i in range(config.epochs):
_ = run(
net,
train_loader,
optimizer,
tracker,
train=True,
prefix='train',
epoch=i,
dataset=train_dataset
) ## prefix needed as ths is passed to tracker- which stroes then train_acc/loss
_ = run(
net,
val_loader,
optimizer,
tracker,
train=False,
prefix='val',
epoch=i
) ## prefix needed as ths is passed to tracker- which stroes then val acc/loss
results = {
'tracker': tracker.to_dict(
), ## tracker saves acc/loss for all 50 epochs- since it appends the values ( lines 91..)
'config': config_as_dict,
'weights': net.state_dict(),
# 'eval': { ## # edit_vedika FT101 you are svaing the results here - you dont need this!
# 'answers': r[0],
# 'accuracies': r[1],
# 'idx': r[2],
# },
'vocab': train_loader.dataset.vocab,
}
saving_target_name = 'epoch_{}.pth'.format(
i
) ## you want to have all finetuned models- so save every model at everye epoch
torch.save(
results, os.path.join(target_name, saving_target_name)
) ## keys: "name", "tracker", "config", "weights", "eval", "vocab"
#checkpoint_file = os.path.join('./models/epoch_{}.pth'.format(i))
#torch.save(net, checkpoint_file)
#print('saving model to '+ checkpoint_file)
print('time_taken:', time.time() - start_time)
print(config.model_type)
def main():
if len(sys.argv) > 1:
name = ' '.join(sys.argv[1:])
else:
from datetime import datetime
name = datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
target_name = os.path.join('logs', '{}.pth'.format(name))
print('will save to {}'.format(target_name))
cudnn.benchmark = True
train_loader = data.get_loader(train=True)
val_loader = data.get_loader(val=True)
# Build Model
vocab_size = train_loader.dataset.num_tokens
model = rDAN(num_embeddings=vocab_size,
embedding_dim=config.embedding_dim,
hidden_size=config.hidden_size,
answer_size=config.max_answers)
if config.pretrained:
model.textencoder.load_pretrained(
train_loader.dataset.vocab['question'])
net = nn.DataParallel(model).cuda()
optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad])
tracker = utils.Tracker()
config_as_dict = {
k: v
for k, v in vars(config).items() if not k.startswith('__')
}
for i in range(config.epochs):
_ = run(net,
train_loader,
optimizer,
tracker,
train=True,
prefix='train',
epoch=i)
r = run(net,
val_loader,
optimizer,
tracker,
train=False,
prefix='val',
epoch=i)
results = {
'name': name,
'tracker': tracker.to_dict(),
'config': config_as_dict,
'weights': net.state_dict(),
'eval': {
'answers': r[0],
'accuracies': r[1],
'idx': r[2],
},
'vocab': train_loader.dataset.vocab,
}
torch.save(results, target_name)
def main():
if len(sys.argv) > 1:
name = ' '.join(sys.argv[1:])
else:
from datetime import datetime
name = datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
target_name = os.path.join('logs', '{}.pth'.format(name))
print('will save to {}'.format(target_name))
cudnn.benchmark = True
train_loader = data.get_loader(train=True, batch_size=config.batch_size)
val_loader = data.get_loader(val=True, batch_size=config.batch_size)
#log = torch.load(config.vqa_model_path)
#tokens = len(log['vocab']['question']) + 1
#net = torch.nn.DataParallel(vqa_model.Net(tokens)).cuda()
#net = vqa_model.Net(tokens).cuda()
#net.load_state_dict(log['weights'], strict=False)
vqa_model = model.VQANet()
#vocab = vqa_model.get_vocab()
optimizer = optim.Adam(
[p for p in vqa_model.vqa_net.parameters() if p.requires_grad])
tracker = utils.Tracker()
config_as_dict = {
k: v
for k, v in vars(config).items() if not k.startswith('__')
}
for i in range(config.epochs):
_ = run(vqa_model,
train_loader,
optimizer,
tracker,
train=True,
prefix='train',
epoch=i)
r = run(vqa_model,
val_loader,
optimizer,
tracker,
train=False,
prefix='val',
epoch=i)
#pdb.set_trace()
results = {
'name': name,
'tracker': tracker.to_dict(),
'config': config_as_dict,
'weights': vqa_model.vqa_net.state_dict(),
'eval': {
'answers': r[0],
'accuracies': r[1],
'idx': r[2],
},
'vocab': train_loader.dataset.vocab,
}
torch.save(results, target_name)
def create_tracker(current_tracker, square, positions):
n_tracker = utils.Tracker(positions, current_tracker.index,
current_tracker.tracking, square)
if not n_tracker.noise():
new_trackers.append(n_tracker)
G_opt = optim.Adam(list(netG.parameters()), lr=args.lrG)
D_opt = optim.Adam(list(netD.parameters()), lr=args.lrD)
GS_opt = optim.Adam(list(netGS.parameters()), lr=args.lrG)
# loss criteria
logsigmoid = nn.LogSigmoid()
mse = nn.MSELoss(reduce=False)
LOG2 = Variable(torch.from_numpy(np.ones(1) * np.log(2)).float())
print(LOG2)
if torch.cuda.is_available():
LOG2 = LOG2.cuda()
#=========== LOGGING INITIALIZATION ================
vis = utils.init_visdom(args.env)
tracker = utils.Tracker()
tracker_plot = None
scale_plot = None
#============================================================
#============ MAIN TRAINING LOOP ============================
#============================================================
for epoch in range(args.max_iter):
for it, (s_inputs, t_inputs) in enumerate(loader):
s_inputs, t_inputs = Variable(s_inputs), Variable(t_inputs)
if torch.cuda.is_available():
s_inputs, t_inputs = s_inputs.cuda(), t_inputs.cuda()
def main():
if len(sys.argv) > 1:
name = ' '.join(sys.argv[1:])
else:
from datetime import datetime
name = datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
target_name = os.path.join('logs', '{}.pth'.format(name))
print('will save to {}'.format(target_name))
cudnn.benchmark = True
train_loader = data.get_loader(train=True)
val_loader = data.get_loader(val=True)
net = nn.DataParallel(model.Net()).cuda()
optim_params = [{
'params': net.module.text.parameters(),
'lr': config.initial_lr
}, {
'params': net.module.attention.parameters(),
'lr': config.initial_lr
}, {
'params': net.module.classifier.parameters(),
'lr': config.initial_lr
}]
optimizer = optim.Adam(optim_params)
tracker = utils.Tracker()
config_as_dict = {
k: v
for k, v in vars(config).items() if not k.startswith('__')
}
for i in range(config.epochs):
l = run(net,
train_loader,
optimizer,
tracker,
train=True,
prefix='train',
epoch=i)
r = run(net,
val_loader,
optimizer,
tracker,
train=False,
prefix='val',
epoch=i)
results = {
'name': name,
'tracker': tracker.to_dict(),
'config': config_as_dict,
'weights': net.state_dict(),
'eval': {
'answers': r[0],
'accuracies': r[1],
'idx': r[2],
},
'train': {
'answers': l[0],
'accuracies': l[1],
'idx': l[2],
},
'vocab': train_loader.dataset.vocab,
}
torch.save(results, target_name)
import torch
from ddpg import DDPG
#from naf import NAF
from normalized_actions import NormalizedActions
from ounoise import OUNoise
from replay_memory import ReplayMemory, Transition
from rover_domain import Task_Rovers
import utils as utils
from torch.autograd import Variable
#import calculate_rewards
from visualizer import visualize
from D_VAE_Parameters import Parameters
from calculate_rewards import *
args = Parameters()
tracker = utils.Tracker(args, ['rewards'], '')
env = Task_Rovers(args)
torch.manual_seed(args.seed)
np.random.seed(args.seed)
poi_vals = env.set_poi_values()
if not os.path.exists(args.save_foldername): os.makedirs(args.save_foldername)
if args.algo == "NAF":
agent = NAF(args.gamma, args.tau, args.num_hnodes,
env.observation_space.shape[0], env.action_space, args)
else:
agent = DDPG(args.gamma, args.tau, args.num_hnodes,
env.observation_space.shape[0], env.action_space, args)
def main(name=None, config2=None):
print("running on", "cuda:0" if torch.cuda.is_available() else "cpu")
if len(sys.argv) > 1:
name = ' '.join(sys.argv[1:])
else:
from datetime import datetime
if name is None:
name = datetime.now().strftime("%Y-%m-%d_%H:%M:%S")
else:
name = name + datetime.now().strftime("-%Y-%m-%d_%H:%M:%S")
target_name = os.path.join('logs_baseline', '{}.pth'.format(name))
print('will save to {}'.format(target_name))
cudnn.benchmark = True
train_loader = data.get_loader(train=True)
val_loader = data.get_loader(val=True)
net = nn.DataParallel(Net(train_loader.dataset.num_tokens)).cuda()
# def get_activation(name):
# def hook(model, input, output):
# activation[name] = output.detach()
# return hook
# for name, layer in net.named_modules():
# if name == "module.attention.x_conv":
# layer.register_forward_hook(get_activation('attention'))
tracker = utils.Tracker()
global config_as_dict
if config2 is None:
config_as_dict = {
k: v
for k, v in vars(config).items() if not k.startswith('__')
}
else:
config_as_dict = config2
optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad],
weight_decay=config_as_dict["weight_decay"])
for i in range(config_as_dict["epochs"]):
_ = run(net,
train_loader,
optimizer,
tracker,
train=True,
prefix='train',
epoch=i)
r = run(net,
val_loader,
optimizer,
tracker,
train=False,
prefix='val',
epoch=i)
results = {
'name': name,
'tracker': tracker.to_dict(),
'config': config_as_dict,
'weights': net.state_dict(),
'eval': {
'answers': r[0],
'accuracies': r[1],
'idx': r[2],
},
'vocab': train_loader.dataset.vocab,
}
torch.save(results, target_name)
