def train(opt, tr_dataloader, model, optim, lr_scheduler, val_dataloader=None): ''' Train the model with the prototypical learning algorithm ''' if val_dataloader is None: best_state = None train_loss = [] train_acc = [] val_loss = [] val_acc = [] best_acc = 0 for epoch in range(opt.epochs): print('=== Epoch: {} ==='.format(epoch)) tr_iter = iter(tr_dataloader) model.train() for batch in tqdm(tr_iter): optim.zero_grad() x, y = batch x, y = Variable(x), Variable(y) if opt.cuda: x, y = x.cuda(), y.cuda() model_output = model(x) l, acc = loss(model_output, target=y, n_support=opt.num_support_tr) l.backward() optim.step() train_loss.append(l.data[0]) train_acc.append(acc.data[0]) avg_loss = np.mean(train_loss[-opt.iterations:]) avg_acc = np.mean(train_acc[-opt.iterations:]) print('Avg Train Loss: {}, Avg Train Acc: {}'.format(avg_loss, avg_acc)) lr_scheduler.step() if val_dataloader is None: continue val_iter = iter(val_dataloader) model.eval() for batch in val_iter: x, y = batch x, y = Variable(x), Variable(y) if opt.cuda: x, y = x.cuda(), y.cuda() model_output = model(x) l, acc = loss(model_output, target=y, n_support=opt.num_support_tr) val_loss.append(l.data[0]) val_acc.append(acc.data[0]) avg_loss = np.mean(val_loss[-opt.iterations:]) avg_acc = np.mean(val_acc[-opt.iterations:]) postfix = ' (Best)' if avg_acc >= best_acc else ' (Best: {})'.format( best_acc) print('Avg Val Loss: {}, Avg Val Acc: {}{}'.format( avg_loss, avg_acc, postfix)) if avg_acc >= best_acc: torch.save(model.state_dict(), '../best_model.pth') best_acc = avg_acc best_state = model.state_dict() torch.save(model.state_dict(), '../last_model.pth') return best_state
def test(opt, test_dataloader, model, optim): ''' Test the model trained with the prototypical learning algorithm ''' avg_acc = list() copy_net = init_protonet(opt) copy_opt = torch.optim.Adam(params=copy_net.parameters(), lr=opt.learning_rate) for epoch in range(10): test_iter = iter(test_dataloader) for batch in test_iter: copy_net.load_state_dict(model.state_dict()) cur_opt = optim.state_dict() copy_opt.__setstate__(cur_opt['state']) copy_opt.zero_grad() x, y = batch x, y = Variable(x), Variable(y) if opt.cuda: x, y = x.cuda(), y.cuda() model_output = copy_net(x) l, acc = loss(model_output, target=y, n_support=opt.num_support_tr, inner_loop=True) l.backward() copy_opt.step() model_output = copy_net(x) _, acc = loss(model_output, target=y, n_support=opt.num_support_tr) avg_acc.append(acc.data[0]) avg_acc = np.mean(avg_acc) print('Test Acc: {}'.format(avg_acc)) return avg_acc
def test(opt, test_dataloader, model): ''' Test the model trained with the prototypical learning algorithm ''' device = 'cuda:0' if torch.cuda.is_available() and opt.cuda else 'cpu' avg_acc = list() for epoch in range(10): test_iter = iter(test_dataloader) for batch in test_iter: x, y = batch x, y = x.to(device), y.to(device) model_output = model(x) _, acc = loss(model_output, target=y, n_support=opt.num_support_tr) avg_acc.append(acc.item()) avg_acc = np.mean(avg_acc) print('Test Acc: {}'.format(avg_acc)) return avg_acc
def test(opt, test_dataloader, model): ''' Test the model trained with the prototypical learning algorithm ''' avg_acc = list() for epoch in range(10): test_iter = iter(test_dataloader) for batch in test_iter: x, y = batch x, y = Variable(x), Variable(y) if opt.cuda: x, y = x.cuda(), y.cuda() model_output = model(x) l, acc = loss(model_output, target=y, n_support=opt.num_support_tr) avg_acc.append(acc.data[0]) avg_acc = np.mean(avg_acc) print('Test Acc: {}'.format(avg_acc)) return avg_acc
def test(opt, test_dataloader, model): ''' Test the model trained with the prototypical learning algorithm ''' rand_vec = 0.01 * np.random.randn(100, 1600) accs = [] test_iter = iter(test_dataloader) #batches = [test_iter.__next__() for i in range(100)] batch = test_iter.__next__() for idx in range(101): counter = 0 #for batch in batches: x, y = batch x, y = Variable(x), Variable(y) if opt.cuda: x, y = x.cuda(), y.cuda() model_output = model(x) means = obtain_mean(model_output, target=y, n_support=opt.num_support_tr) if idx < 100: means = means.data.numpy() means[4] = means[4] + rand_vec[idx] means = Variable(torch.FloatTensor(means)) _, acc = loss(model_output, means, target=y, n_support=opt.num_support_tr) #avg_acc.append(acc.data[0]) #avg = np.mean(avg_acc) print('Test Acc: {}'.format(acc.data[0])) accs.append(acc.data[0]) for idx in range(100): if accs[idx] > accs[-1]: print('Higher index: {}'.format(idx)) import pdb; pdb.set_trace() return accs
def train(opt, tr_dataloader, model, optim, lr_scheduler, val_dataloader=None): ''' Train the model with the prototypical learning algorithm ''' if val_dataloader is None: best_state = None train_loss = [] train_acc = [] val_loss = [] val_acc = [] pre_metatrain_loss = [] pre_metatrain_acc = [] post_metatrain_loss = [] post_metatrain_acc = [] best_acc = 0 best_model_path = os.path.join(opt.experiment_root, 'best_model.pth') last_model_path = os.path.join(opt.experiment_root, 'last_model.pth') copy_net = init_protonet(opt) copy_opt = torch.optim.Adam(params=copy_net.parameters(), lr=opt.learning_rate) for epoch in range(opt.epochs): print('=== Epoch: {} ==='.format(epoch)) tr_iter = iter(tr_dataloader) model.train() for batch in tqdm(tr_iter): optim.zero_grad() x, y = batch x, y = Variable(x), Variable(y) if opt.cuda: x, y = x.cuda(), y.cuda() model_output = model(x) l, acc = loss(model_output, target=y, n_support=opt.num_support_tr, inner_loop=True) grads = torch.autograd.grad(l, model.parameters(), create_graph=True) adapted_weights = OrderedDict( (name, param - inner_lr * grad) for ((name, param), grad) in zip(model.named_parameters(), grads)) model_output_adapt = model(x, adapted_weights) l, acc = loss(model_output_adapt, target=y, n_support=opt.num_support_tr) l.backward() optim.step() train_loss.append(l.data[0]) train_acc.append(acc.data[0]) avg_loss = np.mean(train_loss[-opt.iterations:]) avg_acc = np.mean(train_acc[-opt.iterations:]) print('Avg Train Loss: {}, Avg Train Acc: {}'.format( avg_loss, avg_acc)) lr_scheduler.step() if val_dataloader is None: continue val_iter = iter(val_dataloader) model.eval() for batch in val_iter: copy_net.load_state_dict(model.state_dict()) cur_opt = optim.state_dict() copy_opt.__setstate__(cur_opt['state']) copy_opt.zero_grad() x, y = batch x, y = Variable(x), Variable(y) if opt.cuda: x, y = x.cuda(), y.cuda() model_output = copy_net(x) l, acc = loss(model_output, target=y, n_support=opt.num_support_val, inner_loop=True) pre_metatrain_loss.append(l.data[0]) pre_metatrain_acc.append(acc.data[0]) l.backward() copy_opt.step() model_output = copy_net(x) l, acc = loss(model_output, target=y, n_support=opt.num_support_val) val_loss.append(l.data[0]) val_acc.append(acc.data[0]) l, acc = loss(model_output, target=y, n_support=opt.num_support_val, inner_loop=True) post_metatrain_loss.append(l.data[0]) post_metatrain_acc.append(acc.data[0]) avg_loss = np.mean(val_loss[-opt.iterations:]) avg_acc = np.mean(val_acc[-opt.iterations:]) avg_pre_metatrain_loss = np.mean(pre_metatrain_loss[-opt.iterations:]) avg_pre_metatrain_acc = np.mean(pre_metatrain_acc[-opt.iterations:]) avg_post_metatrain_loss = np.mean( post_metatrain_loss[-opt.iterations:]) avg_post_metatrain_acc = np.mean(post_metatrain_acc[-opt.iterations:]) postfix = ' (Best)' if avg_acc >= best_acc else ' (Best: {})'.format( best_acc) print('Avg Val Loss: {}, Avg Val Acc: {}{}'.format( avg_loss, avg_acc, postfix)) print('Avg Pre Metatrain Loss: {}, Avg Pre Metatrain Acc: {}'.format( avg_pre_metatrain_loss, avg_pre_metatrain_acc)) print('Avg Post Metatrain Loss: {}, Avg Post Metatrain Acc: {}'.format( avg_post_metatrain_loss, avg_post_metatrain_acc)) if avg_acc >= best_acc: torch.save(model.state_dict(), best_model_path) best_acc = avg_acc best_state = model.state_dict() torch.save(model.state_dict(), last_model_path) for name in ['train_loss', 'train_acc', 'val_loss', 'val_acc']: save_list_to_file(os.path.join(opt.experiment_root, name + '.txt'), locals()[name]) return best_state, best_acc, train_loss, train_acc, val_loss, val_acc
def train(opt, tr_dataloader, model, optim, lr_scheduler, val_dataloader=None): ''' Train the model with the prototypical learning algorithm ''' device = 'cuda:0' if torch.cuda.is_available() and opt.cuda else 'cpu' if val_dataloader is None: best_state = None train_loss = [] train_acc = [] val_loss = [] val_acc = [] best_acc = 0 best_model_path = os.path.join(opt.experiment_root, 'best_model.pth') last_model_path = os.path.join(opt.experiment_root, 'last_model.pth') for epoch in range(opt.epochs): print('=== Epoch: {} ==='.format(epoch)) tr_iter = iter(tr_dataloader) model.train() for batch in tqdm(tr_iter): optim.zero_grad() x, y = batch x, y = x.to(device), y.to(device) model_output = model(x) l, acc = loss(model_output, target=y, n_support=opt.num_support_tr) l.backward() optim.step() train_loss.append(l.item()) train_acc.append(acc.item()) avg_loss = np.mean(train_loss[-opt.iterations:]) avg_acc = np.mean(train_acc[-opt.iterations:]) print('Avg Train Loss: {}, Avg Train Acc: {}'.format( avg_loss, avg_acc)) lr_scheduler.step() if val_dataloader is None: continue val_iter = iter(val_dataloader) model.eval() for batch in val_iter: x, y = batch x, y = x.to(device), y.to(device) model_output = model(x) l, acc = loss(model_output, target=y, n_support=opt.num_support_val) val_loss.append(l.item()) val_acc.append(acc.item()) avg_loss = np.mean(val_loss[-opt.iterations:]) avg_acc = np.mean(val_acc[-opt.iterations:]) postfix = ' (Best)' if avg_acc >= best_acc else ' (Best: {})'.format( best_acc) print('Avg Val Loss: {}, Avg Val Acc: {}{}'.format( avg_loss, avg_acc, postfix)) if avg_acc >= best_acc: torch.save(model.state_dict(), best_model_path) best_acc = avg_acc best_state = model.state_dict() torch.save(model.state_dict(), last_model_path) for name in ['train_loss', 'train_acc', 'val_loss', 'val_acc']: save_list_to_file(os.path.join(opt.experiment_root, name + '.txt'), locals()[name]) return best_state, best_acc, train_loss, train_acc, val_loss, val_acc