def get_loaders_and_tokenizer(en_path, ru_path, smaller_size=None):
en_text, ru_text = load_yandex_data(en_path, ru_path)
if smaller_size is not None:
en_text = en_text[:smaller_size]
ru_text = ru_text[:smaller_size]
en_train, en_valid, ru_train, ru_valid = train_test_split(en_text,
ru_text,
test_size=0.2,
random_state=42)
tokenizer = AutoTokenizer.from_pretrained('t5-small')
train_loader = get_loader(
data_src=ru_train,
data_target=en_train,
tokenizer=tokenizer,
augment_p=0,
batch_size=8,
shuffle=True,
drop_last=True,
num_workers=4,
)
valid_loader = get_loader(
data_src=ru_valid[:50],
data_target=en_valid[:50],
tokenizer=tokenizer,
augment_p=0,
batch_size=128,
shuffle=False,
drop_last=False,
num_workers=1,
)
return train_loader, valid_loader, tokenizer
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()
logs = torch.load("logs/2018-09-21_12:08:23.pth")
# 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 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_transformer.make_model(val_loader.dataset.num_tokens,
3000).cuda()
#net = model.Net(val_loader.dataset.num_tokens).cuda()
net.load_state_dict(logs['weights'])
while (True):
try:
idx = int(input("Enter image idx: "))
except:
print("Invalid!")
idx = int(input("Enter image idx: "))
r = run(net, val_loader, idx)
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 train(args):
train_loader = get_loader(args=args)
if args.ckpt_path:
model, ckpt_info = ModelSaver.load_model(args.ckpt_path, args.gpu_ids)
args.start_epoch = ckpt_info['epoch'] + 1
else:
model_fn = models.__dict__[args.model]
args.D_in = train_loader.D_in
model = model_fn(**vars(args))
model = model.to(args.device)
model.train()
# Get optimizer and scheduler
optimizer = optim.get_optimizer(
filter(lambda p: p.requires_grad, model.parameters()), args)
lr_scheduler = optim.get_scheduler(optimizer, args)
if args.ckpt_path:
ModelSaver.load_optimizer(args.ckpt_path, optimizer, lr_scheduler)
# Get logger, evaluator, saver
loss_fn = optim.get_loss_fn(args.loss_fn, args)
logger = TrainLogger(args, len(train_loader.dataset))
eval_loaders = [
get_loader(args, phase='train', is_training=False),
get_loader(args, phase='valid', is_training=False)
]
evaluator = ModelEvaluator(args, eval_loaders, logger, args.max_eval,
args.epochs_per_eval)
saver = ModelSaver(**vars(args))
# Train model
while not logger.is_finished_training():
logger.start_epoch()
for src, tgt in train_loader:
logger.start_iter()
with torch.set_grad_enabled(True):
pred_params = model.forward(src.to(args.device))
ages = src[:, 1]
loss = loss_fn(pred_params, tgt.to(args.device),
ages.to(args.device), args.use_intvl)
#loss = loss_fn(pred_params, tgt.to(args.device), src.to(args.device), args.use_intvl)
logger.log_iter(src, pred_params, tgt, loss)
optimizer.zero_grad()
loss.backward()
optimizer.step()
logger.end_iter()
metrics = evaluator.evaluate(model, args.device, logger.epoch)
# print(metrics)
saver.save(logger.epoch, model, optimizer, lr_scheduler, args.device,\
metric_val=metrics.get(args.metric_name, None))
logger.end_epoch(metrics=metrics)
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: # 外界获得的参数列表：['/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():
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(args):
start_time = time.time()
if args.edit_set:
print('evaluating on edited VQA')
else:
print('evaluating original VQA')
cudnn.benchmark = True
output_qids_answers = []
if args.split == 'train2014':
_, val_loader = data.get_loader(train=True) #val=True) ## data shuffled only in train
elif args.split == 'val2014':
_, val_loader = data.get_loader(val=True)
elif args.split == 'test2015':
_, val_loader = data.get_loader(test=True)
#test_loader = data.get_loader(test=True)
if args.model_type == 'no_attn':
net = nn.DataParallel(model2.Net(val_loader.dataset.num_tokens)).cuda()
model_path = os.path.join(config.model_path_no_attn)
results_file = os.path.join(config.results_no_attn_pth)
res_pkl = os.path.join(config.results_no_attn_pkl)
MODEL_name = 'CNN_LSTM'
elif args.model_type == 'with_attn':
net = nn.DataParallel(model.Net(val_loader.dataset.num_tokens)).cuda()
model_path = os.path.join(config.model_path_show_ask_attend_answer)
results_file = os.path.join(config.results_with_attn_pth)
res_pkl = os.path.join(config.results_with_attn_pkl)
MODEL_name = 'SAAA'
print('loading model from', model_path)
net.load_state_dict(torch.load(model_path)["weights"]) ### so here you load the weights, essentially the model
print(net)
net.eval()
r = run(net, val_loader, args.edit_set, MODEL_name)
print('saving results to '+ res_pkl )
if args.edit_set:
output_qids_answers += [
{ 'ans_id': p.item(), 'img_id': id,'ques_id':qid.item(),'ss_vc': np.float16(softmax_vector.tolist())} #np.float32(softmax_vector).tolist()
for p,id,qid, softmax_vector in zip(r[0],r[1], r[2], r[3])]
else:
output_qids_answers += [
{ 'ans_id': p.item(), 'img_id': id.item(),'ques_id':qid.item(),'ss_vc': np.float16(softmax_vector.tolist())}
for p,id,qid, softmax_vector in zip(r[0],r[1], r[2], r[3])]
with open(res_pkl, 'wb') as f:
pickle.dump(output_qids_answers,f, pickle.HIGHEST_PROTOCOL)
print('saving pkl complete')
print('time_taken:', time.time() - start_time)
def main():
# Dataset
print('Creating dataset...')
train_loader = data.get_loader(
train=True) #use train loader to load vocab size
test_loader = data.get_loader(test=True, batch_size=args.batch_size)
# Model
checkpoint = os.path.join(args.checkpoint)
if not os.path.exists(checkpoint):
os.makedirs(checkpoint)
model_path = os.path.join(checkpoint, 'best_model.pt')
print('Loading model...')
model = SAN(train_loader.dataset.num_tokens)
model.load_state_dict(torch.load(model_path))
print("Number of parameters: ",
sum([param.nelement() for param in model.parameters()]))
model.cuda()
cudnn.benchmark = True
model.eval()
if not os.path.exists(args.result):
os.makedirs(args.result)
# grad cam
grad_cam = GradCAM(model)
for i, (images, questions, quest_id, image_id, idx,
quest_len) in enumerate(test_loader):
images = Variable(images.cuda(),
requires_grad=True) # add grad to get grad cam
questions = Variable(questions.cuda())
quest_len = Variable(quest_len.cuda())
output, pred = grad_cam.forward(images, questions, quest_len)
grad_cam.backward(output, pred)
grad_map = grad_cam.generate()
raw_image = get_image_from_id(image_id)
question = get_question(test_loader.dataset, idx[0])
answer = test_loader.dataset._index_to_answer(pred)
file_name = '{}_{}_{}.jpg'.format(i, question, answer)
file_name = os.path.join(args.result, file_name)
save_gradcam(file_name, grad_map, raw_image)
file_name = '{}.jpg'.format(i)
file_name = os.path.join(args.result, file_name)
save_image(file_name, raw_image)
# take 50 samples
if i == 200:
break
def main():
path = 'logs/'
files = []
file = '2020-02-05_00:29:21.pth'
results = torch.load(f=path+file, map_location='cpu')
train_loader = data.get_loader(train=True)
test_loader = data.get_loader(test=True)
net = model.Net(train_loader.dataset.num_tokens).cuda()
net.load_state_dict(results['weights'])
print(net)
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():
# Dataset
print('Creating dataset...')
train_loader = data.get_loader(
train=True) #use train loader to load vocab size
test_loader = data.get_loader(test=True, batch_size=args.batch_size)
# Model
checkpoint = os.path.join(args.checkpoint)
model_path = os.path.join(checkpoint, 'best_model.pt')
print('Loading model...')
model = get_vqa_model(args.model, train_loader.dataset.num_tokens)
model.load_state_dict(torch.load(model_path))
print("Number of parameters: ",
sum([param.nelement() for param in model.parameters()]))
if torch.cuda.device_count() > 1:
print("Using", torch.cuda.device_count(), "GPUs!")
model = nn.DataParallel(model)
model.cuda()
cudnn.benchmark = True
model.eval()
acc = 0
num_batches = len(test_loader.dataset) // args.batch_size
bar = progressbar.ProgressBar(max_value=num_batches)
running_loss = 0
result = []
for i, (images, questions, quest_id, _, _,
quest_len) in enumerate(test_loader):
images = Variable(images.cuda())
questions = Variable(questions.cuda())
quest_len = Variable(quest_len.cuda())
outputs = model(images, questions, quest_len)
_, preds = torch.max(outputs.data, 1)
for j in range(preds.size(0)):
ans_idx = preds.cpu()[j]
answer = test_loader.dataset._index_to_answer(ans_idx)
result.append({
u'answer': answer,
u'question_id': int(quest_id[j])
})
bar.update(i, force=True)
result = list(result)
json.dump(result, open('results/result.json', 'w'))
def main(args):
data_loader = get_loader(args.image_dir, args.guesswhat_jsonl, args.voc_dict, args.batch_size)
model = RN(args.batch_size, ???)
criterion = nn.BCELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=args.lr, amsgrad=True)
total_step = len(data_loader)
total_loss = 0
hidden = None
for epoch in tqdm(range(args.epochs)):
for i, (img, question, answer) in enumerate(data_loader):
model.hidden = model.init_hidden()
variable_img = Variable(img)
variable_question = Variable(question)
variable_answer = Variable(answer)
optimizer.zero_grad()
output = model(variable_img, variable_question)
loss = criterion(outpus, loss)
loss.backward()
optimizer.step()
if (i+1)%10 == 0:
print('Epoch [{}/{}], Step [{}/{}], Loss:{:.2f}'.format(epoch+1, args.epochs, i+1, total_step, loss.data[0]))
total_loss += loss.data[0]
torch.save(model.state_dict(), 'ckpt/train_001/epoch{}_loss{:.4f}'.format(epoch, total_loss/len(data_loader)))
total_loss = 0
def test_all(self, vocab):
if self.config.args.feature_extractor == 'cnn':
F = model.CNNFeatureExtractor(self.config, vocab,
self.config.F_layers,
self.config.hidden_dim,
self.config.kernel_num,
self.config.kernel_sizes,
self.config.dropout).cuda()
else:
raise NotImplementedError
P = model.RelationClassifier(self.config.P_layers,
self.config.hidden_dim,
self.config.rel_num, self.config.dropout,
self.config.P_bn).cuda()
F.load_state_dict(
torch.load('{}/{}_F.pth'.format(self.config.checkpoint_dir,
self.config.checkpoint_file)))
P.load_state_dict(
torch.load('{}/{}_P.pth'.format(self.config.checkpoint_dir,
self.config.checkpoint_file)))
ch_with_label_test_data_loader = get_loader(
self.config,
prefix=self.config.ch_with_label_test,
language='ch',
vocab=vocab)
macro_f1, macro_precision, macro_recall, micro_f1, micro_precision, micro_recall, acc = self.test(
ch_with_label_test_data_loader, F, P)
self.log.info(
'Test macro F1: {:4.3f}, macro P: {:4.3f}, macro R: {:4.3f}, micro F1: {:4.3f}, micro P: {:4.3}, micro R: {:4.3f}, Acc: {:4.3f}'
.format(macro_f1, macro_precision, macro_recall, micro_f1,
micro_precision, micro_recall, acc))
def train(opt, test=False, trained_model=None):
output = structure.Output()
mode = 'test' if test else 'train'
babisplit, babiloader = data.get_loader(mode=mode, task_id=opt.task_id, data_id=opt.data_id, train_size=opt.train_size, val=False, ques_id=opt.question_id)
opt.n_edge_type = babisplit.n_edge_type
opt.n_node_type = babisplit.n_node_type
opt.n_label_type = babisplit.n_label_type
net = trained_model if test else model.GGNN(opt).cuda()
net = net.double()
if opt.resume:
logs = torch.load(config.MODEL_PATH)
net.load_state_dict(logs['weights'])
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(net.parameters(), lr=config.LEARNING_RATE)
if test:
net.eval()
else:
net.train()
output.set_net(net)
if config.VERBAL and not test:
print('------------------------ Dataset: '+str(opt.data_id)+' -------------------------------')
num_epoch = 1 if test else opt.epoch
for i in range(num_epoch):
total_loss = []
total_accuracy = []
for adj_matrix, annotation, target in babiloader:
padding = torch.zeros(len(annotation), opt.n_node_type, opt.hidden_dim - config.ANNOTATION_DIM[str(opt.task_id)]).double()
x = torch.cat((annotation, padding), 2)
x = Variable(x.cuda())
m = Variable(adj_matrix.cuda())
a = Variable(annotation.cuda())
t = Variable(target.cuda()).long()
pred = net(x, a, m)
if opt.task_id == 19:
# consider each step as a prediction
pred = pred.view(-1, pred.shape[-1])
t = t.view(-1)
loss = criterion(pred, t)
if not test:
net.zero_grad()
loss.backward()
optimizer.step()
total_loss.append(loss.item())
accuracy = (pred.max(1)[1] == t).float().mean()
total_accuracy.append(accuracy.item())
if config.VERBAL:
print(mode + ' Epoch: ' + str(i) + ' Loss: {:.3f} '.format(sum(total_loss) / len(total_loss)) + ' Accuracy: {:.3f} '.format(sum(total_accuracy) / len(total_accuracy)))
output.set_loss(sum(total_loss) / len(total_loss))
output.set_accuracy(sum(total_accuracy) / len(total_accuracy))
return output
def main():
dataset_name = 'vqa1'
target_name = os.path.join('logs', '{}_test.pth'.format(dataset_name))
print('will save to {}'.format(target_name))
cudnn.benchmark = True
test_loader = data.get_loader(test=True)
checkpoint = torch.load('logs/2017-08-04_00:55:19.pth')
tokens = len(checkpoint['vocab']['question']) + 1
net = torch.nn.DataParallel(model.Net(tokens))
net.load_state_dict(checkpoint['weights'])
optimizer = optim.Adam([p for p in net.parameters() if p.requires_grad])
tracker = []
tracker.load_state_dict(checkpoint['tracker'])
config.load_state_dict(checkpoint['config'])
t = run_test(net, test_loader, optimizer, tracker, prefix='test', epoch=1)
results = {
'name': dataset_name,
'tracker': tracker.to_dict(),
'weights': net.state_dict(),
'eval': {
'answers': t[0],
'accuracies': t[1],
'idx': t[2],
def main(epochs, batch_size, coef, mean, temp, baseline, data):
train_loader, test_loader = get_loader(data, batch_size)
logdir = training_logger_dir(data, baseline, mean, temp, coef)
if os.path.exists(logdir):
shutil.rmtree(logdir)
logger = tensorboardX.SummaryWriter(logdir)
model = get_network(data, baseline, mean=mean, temp=temp)
model.cuda()
optimizer = optim.Adam(params=model.parameters(), lr=1e-3)
l0_loss = lambda output, target: F.cross_entropy(output[
0], target) + coef / len(train_loader.dataset) * output[1]
loss_f = F.cross_entropy if baseline else l0_loss
trainer = Trainer(model, optimizer, loss_f, logger)
if not baseline:
correct = lambda output, target: (output[0].max(dim=1)[1] == target
).sum().item()
trainer.correct = correct
trainer.start(epochs, train_loader, test_loader)
if not os.path.exists("pt"):
os.mkdir("pt")
name = training_checkpoint(data, baseline)
torch.save(model.state_dict(), name)
def main():
if len(sys.argv) != 2:
print(
"Usage: enter degenerate/ baseline/ modified_attention/ big/ combined only"
)
return
name = sys.argv[1]
if name == "degenerate":
import model_degenerate
Net = model_degenerate.Net
elif name == "baseline":
import model_baseline
Net = model_baseline.Net
elif name == "modified_attention":
import model_modified_attention
Net = model_modified_attention.Net
elif name == "big":
import model_big
Net = model_big.Net
elif name == "combined":
import model_combined
Net = model_combined.Net
else:
print("Invalid name, try again")
return
import data
test_loader = data.get_loader(test=True)
net = nn.DataParallel(Net(test_loader.dataset.num_tokens)).cuda()
name = name + datetime.now().strftime("-%Y-%m-%d_%H:%M:%S")
target_name = os.path.join('logs_test', '{}.pth'.format(name))
print('will save to {}'.format(target_name))
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 main():
# set GPU ID
os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu
cudnn.benchmark = True
# check save path
save_path = args.save_path
if not os.path.exists(save_path):
os.makedirs(save_path)
# make dataloader
train_loader, test_loader, \
test_onehot, test_label = dataset.get_loader(args.data,
args.data_path,
args.batch_size)
# set num_class
if args.data == 'cifar100':
num_class = 100
else:
num_class = 10
# set num_classes
model_dict = {
"num_classes": num_class,
}
# set network
if args.model == 'res':
model = resnet.resnet110(**model_dict).cuda()
elif args.model == 'dense':
model = densenet_BC.DenseNet3(depth=100,
num_classes=num_class,
growth_rate=12,
reduction=0.5,
bottleneck=True,
dropRate=0.0).cuda()
elif args.model == 'vgg':
model = vgg.vgg16(**model_dict).cuda()
# set criterion
cls_criterion = nn.CrossEntropyLoss().cuda()
# make logger
result_logger = utils.Logger(os.path.join(save_path, 'result.log'))
# load pretrained model
model_state_dict = torch.load(os.path.join(args.save_path,
'{0}.pth'.format(args.file_name)))
model.load_state_dict(model_state_dict)
# calc measure
acc, aurc, eaurc, aupr, fpr, ece, nll, brier = metrics.calc_metrics(test_loader,
test_label,
test_onehot,
model,
cls_criterion)
# result write
result_logger.write([acc,aurc*1000,eaurc*1000,aupr*100,fpr*100,ece*100,nll*10,brier*100])
def run():
train_loader = data.get_loader("train")
val_loader = data.get_loader("val")
test_loader = data.get_loader("test")
if config.load_model:
model = mlpmodel.MLP.load()
else:
model = mlpmodel.MLP(config.input_size, config.hidden_size,
config.output_size, config.CUDA)
routine.train(model, train_loader, val_loader)
test_outputs = routine.predict(model, test_loader)
try:
np.savetxt('prediction.csv', test_outputs, delimiter=",")
except:
print("prediction not saved")
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():
model = Model(cfg.MODEL.MLP.INPUT_SIZE, cfg.MODEL.MLP.HIDDEN_SIZE,
cfg.MODEL.MLP.OUTPUT_SIZE)
logger = setup_logger(cfg.SYSTEM.EXP_NAME, cfg.SYSTEM.SAVE_DIR, 0)
for tid in range(cfg.SOLVER.NUM_TASKS):
train_loader = get_loader(cfg, tid)
train(cfg, model, train_loader, logger)
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():
setup()
session = Session()
session.create()
print('PyTorch {}'.format(torch.__version__))
if args.train_path:
train_data_loader = data.get_loader(args.data, args.train_path)
else:
train_data_loader = None
if args.test_path:
test_data_loader = data.get_loader(args.data, args.test_path)
elif args.aux_inpath:
test_data_loader = data.get_loader(args.data, args.aux_inpath)
else:
test_data_loader = None
# 4 modes: Train (with data/train), test (with data/test), aux-test (with custom aux_inpath), dump-training-set
if args.run_mode == config.RUN_TRAIN:
train(session.generator,
session.encoder,
session.g_running,
train_data_loader,
test_data_loader,
session=session,
total_steps=args.total_kimg * 1000,
train_mode=args.train_mode)
elif args.run_mode == config.RUN_TEST:
if args.reconstructions_N > 0 or args.interpolate_N > 0:
evaluate.Utils.reconstruction_dryrun(session.generator,
session.encoder,
test_data_loader,
session=session)
evaluate.tests_run(session.generator,
session.encoder,
test_data_loader,
session=session,
writer=writer)
elif args.run_mode == config.RUN_DUMP:
session.phase = args.start_phase
data.dump_training_set(train_data_loader, args.dump_trainingset_N,
args.dump_trainingset_dir, session)
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 __init__(self, conf):
"""Constructor
Inputs:
conf: Config object
"""
self.cuda = conf.cuda
self.device = conf.device
self.seed = conf.seed
self.lr = conf.lr
self.epochs = conf.epochs
self.save_epoch = conf.save_epoch
self.batch_size = conf.batch_size
self.log_interval = conf.log_interval
self.data_dir = conf.data_dir
self.save_path = conf.save_path
self.layers = conf.layers
self.txt_logger = create_logger("FlowNet-Train", "logs/")
if not os.path.exists(self.save_path):
os.makedirs(self.save_path, exist_ok=True)
torch.manual_seed(self.seed)
# kwargs = {'num_workers': 4, 'pin_memory': True} if self.cuda else {}
self.train_loader = get_loader(imageDir=self.data_dir +
'train/distorted',
flowDir=self.data_dir + 'train/flow/',
batch_size=self.batch_size)
self.val_loader = get_loader(imageDir=self.data_dir + 'val/distorted/',
flowDir=self.data_dir + 'val/flow/',
batch_size=self.batch_size)
self.model = FlowNet(layers=self.layers)
self.criterion = EPELoss()
self.globaliter = 0
if torch.cuda.device_count() > 1:
print("Let's use", torch.cuda.device_count(), "GPUs!")
self.model = nn.DataParallel(self.model)
if self.cuda:
self.model = self.model.cuda()
self.criterion = self.criterion.cuda()
self.optimizer = torch.optim.Adam(self.model.parameters(), lr=self.lr)
self.tf_logger = TFLogger(r'tensorboard_logs/FlowNet/')
