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/')