def getStat(self):
"""Get the mean and std value for a certain dataset."""
print('Compute mean and variance for training data.')
# train_data = cub200.CUB200(
# root=self._path['cub200'], train=True,
# transform=torchvision.transforms.ToTensor(), download=True)
# train_loader = torch.utils.data.DataLoader(
# train_data, batch_size=1, shuffle=False, num_workers=4,
# pin_memory=True)
trainset = CUB200_loader(os.getcwd() + '/data/CUB_200_2011')
train_loader = data.DataLoader(trainset,
batch_size=4,
shuffle=False,
collate_fn=trainset.CUB_collate,
num_workers=1)
mean = torch.zeros(3)
std = torch.zeros(3)
for X, _ in train_loader:
for d in range(3):
mean[d] += X[:, d, :, :].mean()
std[d] += X[:, d, :, :].std()
mean.div_(len(trainset))
std.div_(len(trainset))
print(mean)
print(std)
def getPosition():
trainset = CUB200_loader(os.getcwd() + '/data/CUB_200_2011')
train_loader = data.DataLoader(trainset,
batch_size=batch_size,
shuffle=False,
collate_fn=trainset.CUB_collate,
num_workers=1) # shuffle?
ret = [[] for i in range(512)]
with torch.no_grad():
cnt = 0
for X, y in train_loader:
pos = net(X)
cnt += X.size()[0]
# if(cnt%10==0):
# print(cnt,flush=False)
for i, c in zip(pos, range(512)):
for j in i:
ret[c].append(j[0].item())
ret[c].append(j[1].item())
return ret
def main():
net = torch.nn.DataParallel(GTBNN()).cuda()
net.load_state_dict(torch.load('GCN_STN_BLN_DiffLrCUB.pth'))
net.eval()
testset = CUB200_loader(os.getcwd() + '/data/CUB_200_2011', split='test')
test_loader = data.DataLoader(testset,
batch_size=1,
shuffle=False,
collate_fn=testset.CUB_collate,
num_workers=4)
num_correct = 0
num_total = 0
for X, y in test_loader:
# Data.
X = torch.autograd.Variable(X.cuda())
y = torch.autograd.Variable(y.cuda())
X.requires_grad = True
# Prediction.
score = net(X)
_, prediction = torch.max(score.data, 1)
num_total += y.size(0)
num_correct += torch.sum(prediction == y.data).item()
print('Test accuracy on CUB_200_2011 dataset is %.2f%%' %
(100 * num_correct / num_total))
def __init__(self, options, path):
"""Prepare the network, criterion, solver, and data.
Args:
options, dict: Hyperparameters.
"""
print('Prepare the network and data.')
self._options = options
self._path = path
# Network.
#self._net = torch.nn.DataParallel(BCNN()).cuda()
#no cuda
self._net = BCNN_STN()
# Load the model from disk.
#self._net.load_state_dict(torch.load(self._path['model']))#not now
print(self._net)
# Criterion.
#self._criterion = torch.nn.CrossEntropyLoss().cuda()
self._criterion = torch.nn.CrossEntropyLoss()
# Solver.
self._solver = torch.optim.SGD(
self._net.parameters(),
lr=self._options['base_lr'],
momentum=0.9,
weight_decay=self._options['weight_decay'])
self._scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(
self._solver,
mode='max',
factor=0.1,
patience=3,
verbose=True,
threshold=1e-4)
train_transforms = torchvision.transforms.Compose([
torchvision.transforms.Resize(size=448), # Let smaller edge match
torchvision.transforms.RandomHorizontalFlip(),
torchvision.transforms.RandomCrop(size=448),
torchvision.transforms.ToTensor(),
torchvision.transforms.Normalize(mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225))
])
test_transforms = torchvision.transforms.Compose([
torchvision.transforms.Resize(size=448),
torchvision.transforms.CenterCrop(size=448),
torchvision.transforms.ToTensor(),
torchvision.transforms.Normalize(mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225))
])
# train_data = cub200.CUB200(
# root=self._path['cub200'], train=True, download=True,
# transform=train_transforms)
# test_data = cub200.CUB200(
# root=self._path['cub200'], train=False, download=True,
# transform=test_transforms)
# self._train_loader = torch.utils.data.DataLoader(
# train_data, batch_size=self._options['batch_size'],
# shuffle=True, num_workers=4, pin_memory=True)
# self._test_loader = torch.utils.data.DataLoader(
# test_data, batch_size=16,
# shuffle=False, num_workers=4, pin_memory=True)
trainset = CUB200_loader(os.getcwd() + '/data/CUB_200_2011')
testset = CUB200_loader(os.getcwd() + '/data/CUB_200_2011')
self._train_loader = data.DataLoader(
trainset,
batch_size=self._options['batch_size'],
shuffle=True,
collate_fn=trainset.CUB_collate,
num_workers=1) #shuffle?
self._test_loader = data.DataLoader(
testset,
batch_size=self._options['batch_size'],
shuffle=False,
collate_fn=testset.CUB_collate,
num_workers=1)
def main():
net = torch.nn.DataParallel(GTBNN()).cuda()
print(net)
trainset = CUB200_loader(os.getcwd() + '/data/CUB_200_2011')
testset = CUB200_loader(os.getcwd() + '/data/CUB_200_2011', split='test')
train_loader = data.DataLoader(trainset,
batch_size=16,
shuffle=True,
collate_fn=trainset.CUB_collate,
num_workers=4) # shuffle?
test_loader = data.DataLoader(testset,
batch_size=16,
shuffle=False,
collate_fn=testset.CUB_collate,
num_workers=4)
criterion = torch.nn.CrossEntropyLoss()
conv_params = list(map(
id, net.module.features.parameters())) #Don't learn convNet
# gcn_params = list(map(id, net.module.fc1_.parameters())) \
# + list(map(id, net.module.fc2_.parameters())) \
# + list(map(id, net.module.fc3_.parameters())) \
# + list(map(id, net.module.fc1.parameters())) \
# + list(map(id, net.module.fc2.parameters())) \
# + list(map(id, net.module.fc3.parameters()))
gcn_params = list(map(id, net.module.fc1.parameters())) \
+ list(map(id, net.module.fc2.parameters())) \
+ list(map(id, net.module.fc3.parameters()))
stn_params = list(map(id, net.module.localization[0].parameters())) \
+ list(map(id, net.module.localization[1].parameters())) \
+ list(map(id, net.module.localization[2].parameters())) \
+ list(map(id, net.module.fc_loc[0].parameters())) \
+ list(map(id, net.module.fc_loc[1].parameters())) \
+ list(map(id, net.module.fc_loc[2].parameters()))
bcn_fc_params = list(map(id, net.module.bfc1.parameters())) \
+ list(map(id, net.module.bfc2.parameters())) \
+ list(map(id, net.module.bfc3.parameters()))
bcn_conv_params = list(
filter(lambda p: id(p) not in gcn_params + conv_params + bcn_fc_params,
net.module.parameters()))
gcn_params = list(
filter(lambda p: id(p) in gcn_params, net.module.parameters()))
stn_params = list(
filter(lambda p: id(p) in stn_params, net.module.parameters()))
bcn_fc_params = list(
filter(lambda p: id(p) in bcn_fc_params, net.module.parameters()))
solver = torch.optim.SGD([{
'params': gcn_params,
'lr': 0.01
}, {
'params': bcn_fc_params,
'lr': 0.01
}, {
'params': stn_params,
'lr': 1.0
}],
lr=0.001,
momentum=0.9,
weight_decay=1e-8)
lrscheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(solver,
mode='max',
factor=0.2,
patience=3,
verbose=True,
threshold=1e-4)
# solver = torch.optim.Adam(net.parameters(),lr=0.3,weight_decay=1e-4)
# lrscheduler=torch.optim.lr_scheduler.CosineAnnealingLR(solver,T_max=32)
def _accuracy(net, data_loader):
net.train(False)
num_correct = 0
num_total = 0
for X, y in data_loader:
X = torch.autograd.Variable(X.cuda())
y = torch.autograd.Variable(y.cuda())
X.requires_grad = True
score = net(X)
_, prediction = torch.max(score.data, 1)
num_total += y.size(0)
num_correct += torch.sum(prediction == y.data).item()
net.train(True)
return 100 * num_correct / num_total
best_acc = 0.0
best_epoch = None
for t in range(100):
epoch_loss = []
num_correct = 0
num_total = 0
cnt = 0
print('Epoch ' + str(t), flush=True)
for X, y in train_loader:
X = torch.autograd.Variable(X.cuda())
y = torch.autograd.Variable(y.cuda())
solver.zero_grad()
X.requires_grad = True
score = net(X)
loss = criterion(score, y)
epoch_loss.append(loss.data.item())
_, prediction = torch.max(score.data, 1)
num_total += y.size(0)
num_correct += torch.sum(prediction == y.data)
loss.backward()
solver.step()
if (num_total >= cnt * 2000):
cnt += 1
logger.info("Train Acc: " +
str((100 * num_correct / num_total).item()) + "%" +
"\n" + str(num_correct) + " " + str(num_total) +
"\n" + str(prediction) + " " + str(y.data) + "\n" +
str(loss.data))
logger.handlers[1].flush()
train_acc = (100 * num_correct / num_total).item()
test_acc = _accuracy(net, test_loader)
lrscheduler.step(test_acc)
# lrscheduler.step(sum(epoch_loss) / len(epoch_loss))
if test_acc > best_acc:
best_acc = test_acc
best_epoch = t + 1
print('*', end='', flush=True)
logger.info('%d\t%.10f\t%4.3f\t\t%4.2f%%\t\t%4.2f%%' %
(t + 1, solver.param_groups[0]['lr'],
sum(epoch_loss) / len(epoch_loss), train_acc, test_acc))
logger.handlers[1].flush()
torch.save(net.module.state_dict(), './data/GCN_STN_BLN_DiffLr.pth')
def main():
# tmpNet=torch.nn.DataParallel(CGNN()).cuda()
# tmpNet.load_state_dict(torch.load("preTrainedGCNetModel.pth"))
# tmpNet.eval()
# state_dict=tmpNet.state_dict()
# print(state_dict)
train_transforms = torchvision.transforms.Compose([
torchvision.transforms.ToPILImage(),
torchvision.transforms.Resize(size=448), # Let smaller edge match
torchvision.transforms.RandomHorizontalFlip(),
torchvision.transforms.RandomCrop(size=448),
torchvision.transforms.ToTensor(),
torchvision.transforms.Normalize(mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225))
])
#####test code
net = torch.nn.DataParallel(GTBNN()).cuda()
print(net)
trainset = CUB200_loader(os.getcwd() + '/data/CUB_200_2011',
transform=train_transforms)
testset = CUB200_loader(os.getcwd() + '/data/CUB_200_2011', split='test')
train_loader = data.DataLoader(trainset,
batch_size=1,
shuffle=True,
collate_fn=trainset.CUB_collate,
num_workers=4) # shuffle?
test_loader = data.DataLoader(testset,
batch_size=1,
shuffle=False,
collate_fn=testset.CUB_collate,
num_workers=4)
criterion = torch.nn.CrossEntropyLoss()
# solver = torch.optim.SGD(
# net.parameters(), lr=0.1, weight_decay=1e-5)
solver = torch.optim.Adam(net.parameters(), lr=0.01, weight_decay=1e-4)
lrscheduler = torch.optim.lr_scheduler.CosineAnnealingLR(solver, T_max=32)
def _accuracy(net, data_loader):
"""Compute the train/test accuracy.
Args:
data_loader: Train/Test DataLoader.
Returns:
Train/Test accuracy in percentage.
"""
net.train(False)
num_correct = 0
num_total = 0
for X, y in data_loader:
# Data.
X = torch.autograd.Variable(X.cuda())
y = torch.autograd.Variable(y.cuda())
X.requires_grad = True
# Prediction.
score = net(X)
_, prediction = torch.max(score.data, 1)
num_total += y.size(0)
num_correct += torch.sum(prediction == y.data).item()
net.train(True) # Set the model to training phase
return 100 * num_correct / num_total
best_acc = 0.0
best_epoch = None
for t in range(100):
epoch_loss = []
num_correct = 0
num_total = 0
cnt = 0
print('Epoch ' + str(t), flush=True)
for X, y in train_loader:
X = torch.autograd.Variable(X.cuda())
y = torch.autograd.Variable(y.cuda())
print(y, flush=True)
solver.zero_grad()
result = X.data[0].permute(1, 2, 0).cpu().numpy()
result = normalize(result)
print(result.size)
plt.imshow(result)
plt.show()
a = input('Choose or not?')
if (eval(a) == 1):
# Forward pass.
X.requires_grad = True
score = net(X)
break
else:
continue
break # for img
loss = criterion(score, y)
# epoch_loss.append(loss.data[0])
epoch_loss.append(loss.data.item())
# Prediction.
_, prediction = torch.max(score.data, 1)
num_total += y.size(0)
num_correct += torch.sum(prediction == y.data)
loss.backward()
solver.step()
lrscheduler.step()
if (num_total >= cnt * 500):
cnt += 1
# print("Train Acc: " + str((100 * num_correct / num_total).item()) + "%" + "\n" + str(
# num_correct) + " " + str(num_total) + "\n" + str(prediction) + " " + str(y.data) + "\n" + str(
# loss.data), flush=True)
logger.info("Train Acc: " +
str((100 * num_correct / num_total).item()) + "%" +
"\n" + str(num_correct) + " " + str(num_total) +
"\n" + str(prediction) + " " + str(y.data) + "\n" +
str(loss.data))
logger.handlers[1].flush()
lrscheduler.step()
if (num_total >= cnt * 500):
cnt += 1
# print("Train Acc: " + str((100 * num_correct / num_total).item()) + "%" + "\n" + str(
# num_correct) + " " + str(num_total) + "\n" + str(prediction) + " " + str(y.data) + "\n" + str(
# loss.data), flush=True)
logger.info("Train Acc: " +
str((100 * num_correct / num_total).item()) + "%" +
"\n" + str(num_correct) + " " + str(num_total) +
"\n" + str(prediction) + " " + str(y.data) + "\n" +
str(loss.data))
logger.handlers[1].flush()
# break
if __name__ == '__main__':
# main()
trainset = CUB200_loader(os.getcwd() + '/data/CUB_200_2011')
train_loader = data.DataLoader(trainset,
batch_size=1,
shuffle=False,
collate_fn=trainset.CUB_collate,
num_workers=1) # shuffle?
theta = torch.Tensor([[1, 0, -0.5], [0, 1, 0]])
theta = theta.view(-1, 2, 3)
for X, y in train_loader:
visualize(X[0])
grid = F.affine_grid(theta, X.size())
X = F.grid_sample(X, grid)
visualize(X[0])