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])