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
