def train(epoch, net, optimizer):
print("\nEpoch: %d" % epoch)
net.train()
train_loss = 0
correct = 0
total = 0
# optimizer = lr_scheduler(optimizer, epoch, init_lr=0.002, decay_epoch=start_epoch)
for batch_idx, (inputs, targets) in enumerate(train_loader):
if USE_GPU:
inputs, targets = inputs.cuda(), targets.cuda()
inputs, targets = Variable(inputs), Variable(targets)
optimizer.zero_grad()
out = net(inputs)
loss = criterion(out, targets)
loss.backward()
optimizer.step()
train_loss += loss.data[0]
_, predicted = torch.max(out.data, 1)
total += targets.size(0)
correct += predicted.eq(targets.data).cpu().sum()
progress_bar(
batch_idx, len(train_loader), "Loss: %.3f | Acc: %.3f%% (%d/%d)" %
(train_loss /
(batch_idx + 1), 100. * correct / total, correct, total))
log.write(str(epoch) + ' ' + str(correct / total) + ' ')
def train(epoch, optimizer):
print("\nEpoch: %d" % epoch)
net.train()
train_loss = 0
correct = 0
total = 0
optimizer = lr_scheduler(optimizer, epoch, init_lr=0.0008, decay_epoch=start_epoch)
for batch_idx, (inputs, targets) in enumerate(train_loader):
if USE_GPU:
inputs, targets = inputs.cuda(), targets.cuda()
optimizer.zero_grad()
inputs, targets = Variable(inputs), Variable(targets, requires_grad=False)
out1, out2, tar, emb_w = net(inputs, targets, epoch, batch_idx)
loss = comp_loss(out1, out2, tar, emb_w, targets, args.mode)
loss.backward()
optimizer.step()
train_loss += loss.data[0]
_, predicted = torch.max(out1.data, 1)
total += targets.size(0)
correct += predicted.eq(targets.data).cpu().sum()
progress_bar(batch_idx, len(train_loader), "Loss: %.3f | Acc: %.3f%% (%d/%d)"
% (train_loss / (batch_idx + 1), 100. * correct / total, correct, total))
log.write(str(epoch) + ' ' + str(correct / total) + ' ')
if args.mode != "baseline":
pickle.dump(emb_w.data.cpu().numpy(),
open("./log/embed/" + MODEL_NAME + '_' + args.mode + "embedding.pkl", "wb"))
def test(epoch):
global best_acc
net.eval()
test_loss, correct, total, loss = 0, 0, 0, 0
for batch_idx, (inputs, targets) in enumerate(test_loader):
if USE_GPU:
inputs, targets = inputs.cuda(), targets.cuda()
inputs, targets = Variable(inputs, volatile=True), Variable(targets)
out, _, _, _ = net(inputs, targets, -1, batch_idx)
loss = F.cross_entropy(out, targets)
test_loss = loss.data[0]
_, predicted = torch.max(out.data, 1)
total += targets.size(0)
correct += predicted.eq(targets.data).cpu().sum()
acc = 100. * correct / total
progress_bar(batch_idx, len(test_loader), 'Loss: %.3f | Acc: %.3f%% (%d/%d)'
% (test_loss / (batch_idx + 1), acc, correct, total))
log.write(str(correct / total) + ' ' + str(test_loss) + '\n')
log.flush()
acc = 100. * correct / total
if epoch > 15 and acc > best_acc:
print("Saving checkpoint")
state = {
'net': net,
'acc': acc,
'epoch': epoch,
'optimizer': optimizer
}
if not os.path.isdir("checkpoints"):
os.mkdir('checkpoints')
torch.save(state, "./checkpoints/" + args.mode + "_" + MODEL_SAVE_FILE)
best_acc = acc
def train(epoch):
print("\nEpoch: %d" % epoch)
net.train()
train_loss, correct, total, loss = 0, 0, 0, 0
for batch_idx, (batch_x, target) in enumerate(train_loader):
batch_x = augmentation(batch_x)
target = torch.LongTensor(target)
labels = torch.sparse.torch.eye(NUM_CLASSES).index_select(dim=0,
index=target)
if args.cuda:
batch_x, labels = batch_x.cuda(), labels.cuda()
batch_x, labels = Variable(batch_x), Variable(labels)
optimizer.zero_grad()
classes, reconstructions = net(batch_x, labels)
loss = capsuleLoss(batch_x, labels, classes, reconstructions)
loss.backward()
optimizer.step()
train_loss += loss.data[0]
total += target.size(0)
pred = classes.data.max(1, keepdim=True)[1].cpu()
correct += pred.eq(target.view_as(pred)).sum()
progress_bar(
batch_idx, len(train_loader), "Loss: %.3f | Acc: %.3f%% (%d/%d)" %
(train_loss /
(batch_idx + 1), 100. * correct / total, correct, total))
def train(epoch, net, optimizer):
print("\nEpoch: %d" % epoch)
net.train()
train_loss = 0
correct = 0
total = 0
# optimizer = lr_scheduler(optimizer, epoch, init_lr=0.002, decay_epoch=start_epoch)
for batch_idx, (inputs, targets) in enumerate(train_loader):
y_emb = y_encoding(targets)
if USE_GPU:
inputs, y_emb = inputs.cuda(), y_emb.cuda()
inputs, y_emb = Variable(inputs, requires_grad=True), Variable(y_emb, requires_grad=True)
optimizer.zero_grad()
v_x, v_y = net(inputs, y_emb)
loss = criterion(v_x, v_y)
loss.backward()
optimizer.step()
train_loss += loss.data[0]
# y_pred = predict_y(v_x, v_y)
total += targets.size(0)
# correct += y_pred.squeeze().cpu().eq(targets.data).sum()
progress_bar(batch_idx, len(train_loader), "Loss: %.3f "% (train_loss / (batch_idx + 1)))
log.write(str(epoch) + ' ' + str(correct / total) + ' ')
def train(epoch):
print("\nEpoch: %d" % epoch)
net.train()
train_loss = 0
correct = 0
total = 0
for batch_idx, (inputs, targets) in enumerate(train_loader):
if USE_GPU:
inputs, targets = inputs.cuda(), targets.cuda()
optimizer.zero_grad()
inputs, targets = Variable(inputs), Variable(targets,
requires_grad=False)
out, theta, _ = net(inputs)
if batch_idx % 60 == 0:
print(theta.cpu()[0])
mode = "baseline"
loss = comp_loss(out, targets, mode)
loss.backward()
optimizer.step()
train_loss += loss.data[0]
_, predicted = torch.max(out.data, 1)
total += targets.size(0)
correct += predicted.eq(targets.data).cpu().sum()
progress_bar(
batch_idx, len(train_loader), "Loss: %.3f | Acc: %.3f%% (%d/%d)" %
(train_loss /
(batch_idx + 1), 100. * correct / total, correct, total))
log.write(str(epoch) + ' ' + str(correct / total) + ' ')
def test(epoch):
global best_acc
net.eval()
test_loss, correct, total, loss = 0, 0, 0, 0
for batch_idx, (inputs, targets) in enumerate(test_loader):
if USE_GPU:
inputs, targets = inputs.cuda(), targets.cuda()
inputs, targets = Variable(inputs, volatile=True), Variable(targets)
out, theta, x1 = net(inputs)
# img = data_loader.un_normalize(x1.data[0].cpu())
# to_pil = torchvision.transforms.ToPILImage()
# img = to_pil(img)
# img.save("imgs/grid/batch_%d.jpg" % batch_idx)
loss = F.cross_entropy(out, targets)
test_loss += loss.data[0]
_, predicted = torch.max(out.data, 1)
total += targets.size(0)
correct += predicted.eq(targets.data).cpu().sum()
acc = 100. * correct / total
progress_bar(
batch_idx, len(test_loader), 'Loss: %.3f | Acc: %.3f%% (%d/%d)' %
(test_loss / (batch_idx + 1), acc, correct, total))
log.write(str(correct / total) + ' ' + str(test_loss) + '\n')
log.write(str(theta.cpu()[0]) + '\n')
log.flush()
img = data_loader.un_normalize(x1.data.cpu()[0])
to_pil = torchvision.transforms.ToPILImage()
img = to_pil(img)
img.save("imgs/grid/test_%d.jpg" % epoch)
acc = 100. * correct / total
if epoch > 30 and acc > best_acc:
print("Saving checkpoint")
state = {
'net': net,
'acc': acc,
'epoch': epoch,
}
if not os.path.isdir("checkpoints"):
os.mkdir('checkpoints')
torch.save(state, "./checkpoints/" + MODEL_SAVE_FILE)
best_acc = acc
def test(epoch, net):
global best_acc
net.eval()
test_loss, correct, total, loss = 0, 0, 0, 0
y_all = torch.arange(0, NUM_CLASSES, out=torch.LongTensor())
y_code = y_encoding(y_all)
test_x = torch.zeros(200, 3, 224, 224)
if USE_GPU:
test_x, y_code = test_x.cuda(), y_code.cuda()
test_x, y_code = Variable(test_x, volatile=True), Variable(y_code, volatile=True)
_, v_y_all = net(test_x, y_code)
for batch_idx, (inputs, targets) in enumerate(test_loader):
y_emb = y_encoding(targets)
if USE_GPU:
inputs, y_emb = inputs.cuda(), y_emb.cuda()
inputs, y_emb = Variable(inputs, volatile=True), Variable(y_emb, volatile=True)
v_x, v_y = net(inputs, y_emb)
loss = criterion(v_x, v_y)
test_loss = loss.data[0]
y_pred = predict_y(v_x, v_y_all)
total += targets.size(0)
correct += y_pred.data.cpu().eq(targets).sum()
acc = 100. * correct / total
progress_bar(batch_idx, len(test_loader), 'Loss: %.3f | Acc: %.3f%% (%d/%d)'
% (test_loss / (batch_idx + 1), acc, correct, total))
log.write(str(correct / total) + ' ' + str(test_loss) + '\n')
log.flush()
acc = 100. * correct / total
if epoch > 9 and acc > best_acc:
print("Saving checkpoint")
state = {
'net': net,
'acc': acc,
'epoch': epoch,
'optimizer': optimizer
}
if not os.path.isdir("checkpoints"):
os.mkdir('checkpoints')
torch.save(state, "./checkpoints/" + MODEL_SAVE_FILE)
best_acc = acc
def test(epoch):
global best_acc
net.eval()
test_loss, correct, total, loss = 0, 0, 0, 0
for batch_idx, (batch_x, target) in enumerate(test_loader):
target = torch.LongTensor(target)
labels = torch.sparse.torch.eye(NUM_CLASSES).index_select(dim=0,
index=target)
if args.cuda:
batch_x, labels = batch_x.cuda(), labels.cuda()
batch_x, labels = Variable(batch_x, volatile=True), Variable(labels)
classes, reconstructions = net(batch_x)
loss = capsuleLoss(batch_x, labels, classes, reconstructions)
test_loss += loss.data[0]
total += target.size(0)
pred = classes.data.max(1, keepdim=True)[1].cpu()
correct += pred.eq(target.view_as(pred)).sum()
progress_bar(
batch_idx, len(test_loader), "Loss: %.3f | Acc: %.3f%% (%d/%d)" %
(test_loss /
(batch_idx + 1), 100. * correct / total, correct, total))
log.write("Test Epoch %d: acc: %.3f | loss: %.3f\n" %
(epoch, correct / total, test_loss))
log.flush()
acc = 100. * correct / len(test_loader.dataset)
if epoch > 0 and acc > best_acc:
print("Saving checkpoint")
state = {
'net': net,
'acc': acc,
'epoch': epoch,
}
if not os.path.isdir("checkpoints"):
os.mkdir('checkpoints')
torch.save(state, "./checkpoints/" + MODEL_SAVE_FILE)
best_acc = acc
def train(epoch):
print("\nEpoch: %d" % epoch)
net.train()
train_loss, correct, total, loss = 0, 0, 0, 0
for batch_idx, (batch_x, target) in enumerate(train_loader):
if args.cuda:
batch_x, target = batch_x.cuda(), target.cuda()
batch_x, target = Variable(batch_x), Variable(target,
requires_grad=False)
optimizer.zero_grad()
output = net(batch_x)
loss = criterion(output, target)
loss.backward()
optimizer.step()
train_loss += loss.data[0]
_, pred = torch.max(output.data, 1)
total += target.size(0)
correct += pred.eq(target.data).cpu().sum()
progress_bar(
batch_idx, len(train_loader), "Loss: %.3f | Acc: %.3f%% (%d/%d)" %
(train_loss /
(batch_idx + 1), 100. * correct / total, correct, total))
def test(epoch):
global best_acc
net.eval()
test_loss, correct, total, loss = 0, 0, 0, 0
for batch_idx, (inputs, targets) in enumerate(train_loader):
if use_cuda:
inputs, targets = inputs.cuda(), targets.cuda()
inputs, targets = Variable(inputs, volatile=True), Variable(
targets, requires_grad=False)
out, _, _, _ = net(inputs, targets, -1, batch_idx)
loss = F.cross_entropy(out, targets)
test_loss = loss.data[0]
_, predicted = torch.max(out.data, 1)
total += targets.size(0)
correct += predicted.eq(targets.data).cpu().sum()
acc = 100. * correct / total
progress_bar(
batch_idx, len(test_loader), 'Loss: %.3f | Acc: %.3f%% (%d/%d)' %
(test_loss / (batch_idx + 1), acc, correct, total))
log.write(str(correct / total) + ' ' + str(test_loss) + '\n')
log.flush()
acc = 100. * correct / total
if epoch > 30 and acc > best_acc:
print("Saving checkpoint")
state = {
'net': net.module if use_cuda else net,
'acc': acc,
'epoch': epoch,
}
if not os.path.isdir("checkpoint"):
os.mkdir('checkpoint')
torch.save(state, "./checkpoint/cifar10_resnet8_" + args.mode + ".pt")
best_acc = acc
def test(epoch):
global best_acc
net.eval()
test_loss, correct, total, loss = 0, 0, 0, 0
for batch_idx, (batch_x, target) in enumerate(test_loader):
if args.cuda:
batch_x, target = batch_x.cuda(), target.cuda()
batch_x, target = Variable(batch_x, volatile=True), Variable(
target, volatile=True, requires_grad=False)
output = net(batch_x)
loss = criterion(output, target)
test_loss += loss.data[0]
_, pred = torch.max(output.data, 1)
total += target.size(0)
correct += pred.eq(target.data).cpu().sum()
progress_bar(
batch_idx, len(test_loader), "Loss: %.3f | Acc: %.3f%% (%d/%d)" %
(test_loss /
(batch_idx + 1), 100. * correct / total, correct, total))
log.write("Test Epoch %d: acc: %.3f | loss: %.3f\n" %
(epoch, correct / total, test_loss))
log.flush()
acc = 100. * correct / len(test_loader.dataset)
if (epoch > 5 or acc > 50.) and acc > best_acc:
print("Saving checkpoint")
state = {
'net': net,
'acc': acc,
'epoch': epoch,
}
if not os.path.isdir("checkpoints"):
os.mkdir('checkpoints')
torch.save(state, "./checkpoints/" + MODEL_SAVE_FILE)
best_acc = acc
def gzsl_test0(epoch, net, optimizer, log, gamma=2.):
NUM_CLASSES = 50 # set the number of classes in your dataset
num_seen_classes = 40
NUM_ATTR = 85
DATA_DIR = "/home/elvis/data/attribute/AwA/Animals_with_Attributes2/zsl/gzsl_test"
BATCH_SIZE = 32
IMAGE_SIZE = 224
best_h = 55
USE_GPU = torch.cuda.is_available()
data_loader = DataLoader(data_dir=DATA_DIR,
image_size=IMAGE_SIZE,
batch_size=BATCH_SIZE)
# train_loader = data_loader.load_data(data_set='train')
test_loader = data_loader.load_data(data_set='val')
criterion = nn.CrossEntropyLoss()
net.eval()
test_loss, correct_seen, correct_unseen, total_seen, total_unseen, total, loss = 0, 0, 0, 0, 0, 0, 0
for batch_idx, (inputs, targets) in enumerate(test_loader):
if USE_GPU:
inputs, targets = inputs.cuda(), targets.cuda()
inputs, targets = Variable(inputs, volatile=True), Variable(targets)
out, attr = net(inputs)
loss = criterion(out, targets)
test_loss = loss.data[0]
logit = out.data
seen_prob, seen_class = torch.max(logit[:, :num_seen_classes], 1)
unseen_prob, unseen_class = torch.max(logit[:, num_seen_classes:], 1)
predicted = seen_class
for i, spi in enumerate(seen_prob):
if seen_prob[i] < unseen_prob[i] * gamma:
predicted[i] = unseen_class[i] + num_seen_classes
total += targets.size(0)
correct_list = predicted.eq(targets.data).cpu()
target_list = targets.data.cpu()
for i, targeti in enumerate(target_list):
if targeti < num_seen_classes:
correct_seen += correct_list[i]
total_seen += 1
else:
correct_unseen += correct_list[i]
total_unseen += 1
acc_seen = 100. * correct_seen / total_seen
if total_unseen > 0:
acc_unseen = 100. * correct_unseen / total_unseen
else:
acc_unseen = 0.
progress_bar(
batch_idx, len(test_loader),
'Loss: %.3f | acc_seen: %.3f%% (%d/%d) | acc_unseen: %.3f%% (%d/%d)'
% (test_loss / (batch_idx + 1), acc_seen, correct_seen, total_seen,
acc_unseen, correct_unseen, total_unseen))
acc_seen = 100. * correct_seen / total_seen
acc_unseen = 100. * correct_unseen / total_unseen
h = 2. / (1. / acc_seen + 1. / acc_unseen)
print("acc_seen: %.3f%% (%d/%d) | acc_unseen: %.3f%% (%d/%d) | H: %.3f%%" %
(acc_seen, correct_seen, total_seen, acc_unseen, correct_unseen,
total_unseen, h))
log.write(str(acc_seen) + ' ' + str(acc_unseen) + ' ' + str(h) + " ")
if h > best_h:
MODEL_SAVE_FILE = "gzsl_awa2_epoch%dacc%d.pth" % (epoch, int(h))
print(MODEL_SAVE_FILE)
state = {'net': net, 'acc': h, 'epoch': epoch, 'optimizer': optimizer}
torch.save(state, "./checkpoints/" + MODEL_SAVE_FILE)
def gzsl_test(epoch, net, optimizer):
NUM_CLASSES = 50 # set the number of classes in your dataset
num_seen_classes = 40
NUM_ATTR = 85
DATA_DIR = "/home/elvis/data/attribute/AwA/Animals_with_Attributes2/zsl/gzsl_test"
BATCH_SIZE = 32
IMAGE_SIZE = 224
best_h = 40
USE_GPU = torch.cuda.is_available()
# order_awa2_attr = np.load("data/order_awa2_attr.npy")
# w_attr_sum = np.sum(w_attr, 0)
# w_attr = w_attr/w_attr_sum
# w_attr[:, 0].sum()
# order_awa2_attr = torch.FloatTensor(order_awa2_attr / 100.).cuda() # 50 * 312
data_loader = DataLoader(data_dir=DATA_DIR,
image_size=IMAGE_SIZE,
batch_size=BATCH_SIZE)
# train_loader = data_loader.load_data(data_set='train')
test_loader = data_loader.load_data(data_set='val')
criterion = nn.CrossEntropyLoss()
net.eval()
test_loss, correct_seen, correct_unseen, total_seen, total_unseen, total, loss = 0, 0, 0, 0, 0, 0, 0
for batch_idx, (inputs, targets) in enumerate(test_loader):
if USE_GPU:
inputs, targets = inputs.cuda(), targets.cuda()
inputs, targets = Variable(inputs, volatile=True), Variable(targets)
out, attr = net(inputs)
loss = criterion(out, targets)
test_loss = loss.data[0]
_, predicted = torch.max(out.data, 1)
total += targets.size(0)
correct_list = predicted.eq(targets.data).cpu()
target_list = targets.data.cpu()
for i, targeti in enumerate(target_list):
if targeti < 40:
correct_seen += correct_list[i]
total_seen += 1
else:
correct_unseen += correct_list[i]
total_unseen += 1
acc_seen = 100. * correct_seen / total_seen
if total_unseen > 0:
acc_unseen = 100. * correct_unseen / total_unseen
else:
acc_unseen = 0.
progress_bar(
batch_idx, len(test_loader),
'Loss: %.3f | acc_seen: %.3f%% (%d/%d) | acc_unseen: %.3f%% (%d/%d)'
% (test_loss / (batch_idx + 1), acc_seen, correct_seen, total_seen,
acc_unseen, correct_unseen, total_unseen))
acc_seen = 100. * correct_seen / total_seen
acc_unseen = 100. * correct_unseen / total_unseen
h = 2. / (1. / acc_seen + 1. / acc_unseen)
print("acc_seen: %.3f%% (%d/%d) | acc_unseen: %.3f%% (%d/%d) | H: %.3f%%" %
(acc_seen, correct_seen, total_seen, acc_unseen, correct_unseen,
total_unseen, h))
if h > best_h:
MODEL_SAVE_FILE = "gzsl_awa2_epoch%dacc%d.pth" % (epoch, int(h))
print(MODEL_SAVE_FILE)
state = {'net': net, 'acc': h, 'epoch': epoch, 'optimizer': optimizer}
torch.save(state, "./checkpoints/" + MODEL_SAVE_FILE)
def zsl_test(epoch, net, optimizer, log):
NUM_CLASSES = 50 # set the number of classes in your dataset
NUM_SEEN = 40
NUM_UNSEEN = NUM_CLASSES - NUM_SEEN
NUM_ATTR = 85
DATA_DIR = "/home/elvis/data/attribute/AwA/Animals_with_Attributes2/zsl/zsl_test"
BATCH_SIZE = 32
IMAGE_SIZE = 224
best_acc = 74
USE_GPU = torch.cuda.is_available()
order_awa2_attr = np.load("data/order_awa2_attr.npy")
# w_attr_sum = np.sum(w_attr, 0)
# w_attr = w_attr/w_attr_sum
# w_attr[:, 0].sum()
order_awa2_attr = order_awa2_attr[NUM_SEEN:, :]
order_awa2_attr = torch.FloatTensor(order_awa2_attr /
100.).cuda() # 50 * 312
net.fc2 = nn.Linear(NUM_ATTR, NUM_CLASSES, bias=False)
net.fc2.weight = nn.Parameter(order_awa2_attr, requires_grad=False)
# print(torch_summarize(net))
# print(net)
net.cuda()
data_loader = DataLoader(data_dir=DATA_DIR,
image_size=IMAGE_SIZE,
batch_size=BATCH_SIZE)
train_loader = data_loader.load_data(data_set='train')
test_loader = data_loader.load_data(data_set='val')
criterion = nn.CrossEntropyLoss()
net.eval()
test_loss, correct, total, loss = 0, 0, 0, 0
correct_bin = np.zeros(NUM_UNSEEN)
total_bin = np.zeros(NUM_UNSEEN)
for batch_idx, (inputs, targets) in enumerate(test_loader):
if USE_GPU:
inputs, targets = inputs.cuda(), targets.cuda()
inputs, targets = Variable(inputs, volatile=True), Variable(targets)
out, attr = net(inputs)
loss = criterion(out, targets)
test_loss = loss.data[0]
_, predicted = torch.max(out.data, 1)
total += targets.size(0)
correct += predicted.eq(targets.data).cpu().sum()
correct_list = predicted.eq(targets.data).cpu()
target_list = targets.data.cpu()
for i, targeti in enumerate(target_list):
correct_bin[targeti] += correct_list[i]
total_bin[targeti] += 1.
acc = 100. * correct / total
progress_bar(
batch_idx, len(test_loader), 'Loss: %.3f | Acc: %.3f%% (%d/%d)' %
(test_loss / (batch_idx + 1), acc, correct, total))
acc = 100. * correct / total
acc_bin = 100. * correct_bin / total_bin
np.save("data/sun_acc_bin.npy", acc_bin)
print("ZSL acc_per_class: %.3f%%(%d/%d)" %
(np.mean(acc_bin), correct_bin[0], total_bin[0]))
log.write(str(np.mean(acc_bin)) + ' ')
if acc > best_acc:
MODEL_SAVE_FILE = "zsl_resnet18_awa2_epoch%dacc%d.pth" % (epoch,
int(acc))
print(MODEL_SAVE_FILE)
state = {
'net': net,
'acc': acc,
'epoch': epoch,
'optimizer': optimizer
}
torch.save(state, "./checkpoints/" + MODEL_SAVE_FILE)
def gzsl_test(epoch, net, optimizer):
NUM_CLASSES = 717 # set the number of classes in your dataset
Num_SEEN = 645
NUM_ATTR = 102
DATA_DIR = "/home/elvis/data/attribute/SUN/zsl/gzsl_test"
BATCH_SIZE = 32
IMAGE_SIZE = 224
best_h = 50
USE_GPU = torch.cuda.is_available()
order_sun_attr = np.load("data/order_sun_attr.npy")
# order_sun_attr[Num_SEEN:, :] = order_sun_attr[Num_SEEN:, :]
# order_cub_attr = order_cub_attr[150:, :]
order_sun_attr = torch.FloatTensor(order_sun_attr).cuda() # 50 * 312
net.fc2 = nn.Linear(NUM_ATTR, NUM_CLASSES, bias=False)
net.fc2.weight = nn.Parameter(order_sun_attr, requires_grad=False)
net.cuda()
data_loader = DataLoader(data_dir=DATA_DIR,
image_size=IMAGE_SIZE,
batch_size=BATCH_SIZE)
# train_loader = data_loader.load_data(data_set='train')
test_loader = data_loader.load_data(data_set='val')
criterion = nn.CrossEntropyLoss()
net.eval()
test_loss, correct_seen, correct_unseen, total_seen, total_unseen, total, loss = 0, 0, 0, 0, 0, 0, 0
for batch_idx, (inputs, targets) in enumerate(test_loader):
if USE_GPU:
inputs, targets = inputs.cuda(), targets.cuda()
inputs, targets = Variable(inputs, volatile=True), Variable(targets)
out, attr = net(inputs)
loss = criterion(out, targets)
test_loss = loss.data[0]
_, predicted = torch.max(out.data, 1)
total += targets.size(0)
correct_list = predicted.eq(targets.data).cpu()
target_list = targets.data.cpu()
for i, targeti in enumerate(target_list):
if targeti < Num_SEEN:
correct_seen += correct_list[i]
total_seen += 1
else:
correct_unseen += correct_list[i]
total_unseen += 1
acc_seen = 100. * correct_seen / total_seen
if total_unseen > 0:
acc_unseen = 100. * correct_unseen / total_unseen
else:
acc_unseen = 0.
progress_bar(
batch_idx, len(test_loader),
'Loss: %.3f | acc_seen: %.3f%% (%d/%d) | acc_unseen: %.3f%% (%d/%d)'
% (test_loss / (batch_idx + 1), acc_seen, correct_seen, total_seen,
acc_unseen, correct_unseen, total_unseen))
acc_seen = 100. * correct_seen / total_seen
acc_unseen = 100. * correct_unseen / total_unseen
h = 2. / (1. / acc_seen + 1. / acc_unseen)
print("acc_seen: %.3f%% (%d/%d) | acc_unseen: %.3f%% (%d/%d) | H: %.3f%%" %
(acc_seen, correct_seen, total_seen, acc_unseen, correct_unseen,
total_unseen, h))
if h > best_h:
MODEL_SAVE_FILE = "gzsl_resnet50_sun_epoch%dacc%d.pth" % (epoch,
int(h))
print(MODEL_SAVE_FILE)
state = {'net': net, 'acc': h, 'epoch': epoch, 'optimizer': optimizer}
torch.save(state, "./checkpoints/" + MODEL_SAVE_FILE)
