bump pytorch to v1.14.0

Author: dizcza

README.md

@@ -1,5 +1,8 @@
-Pytorch implementation of CVPR'17 - Local Binary Convolutional Neural Networks.
-* paper: http://xujuefei.com/lbcnn.html
+### Pytorch implementation of CVPR'17 - Local Binary Convolutional Neural Networks
+
+Juefei-Xu, F., Naresh Boddeti, V., & Savvides, M. (2017). Local binary convolutional neural networks. In Proceedings of the IEEE conference on computer vision and pattern recognition (pp. 19-28).
+
+* paper link: http://xujuefei.com/lbcnn.html
 * original Torch (Lua) repository: https://github.com/juefeix/lbcnn.torch
 
 Training even MNIST with parameters, stated in the original repository, is incredibly slow. Here is an example of training a toy model -- "2 x {BatchNorm2d(8) -> ConvLBP(8, 16, 3) -> Conv(16, 8, 1)} -> FC(200) -> FC(50) -> FC(10)" -- on MNIST:

lbcnn_model.py

@@ -12,7 +12,7 @@ def __init__(self, in_channels, out_channels, kernel_size=3, sparsity=0.5):
         mask_inactive = torch.rand(matrix_proba.shape) > sparsity
         binary_weights.masked_fill_(mask_inactive, 0)
         weights.data = binary_weights
-        weights.requires_grad = False
+        weights.requires_grad_(False)
 
 
 class BlockLBP(nn.Module):

main.py

@@ -6,7 +6,6 @@
 import torch.optim as optim
 import torch.optim.lr_scheduler
 import torch.utils.data
-from torch.autograd import Variable
 from tqdm import tqdm
 
 from lbcnn_model import Lbcnn
@@ -32,7 +31,8 @@ def train(n_epochs=50, lbcnn_depth=2, learning_rate=1e-2, momentum=0.9, weight_d
     if not os.path.exists(models_dir):
         os.makedirs(models_dir)
 
-    train_loader = get_mnist_loader()
+    train_loader = get_mnist_loader(train=True)
+    test_loader = get_mnist_loader(train=False)
     model = Lbcnn(depth=lbcnn_depth)
     use_cuda = torch.cuda.is_available()
     if use_cuda:
@@ -45,11 +45,8 @@ def train(n_epochs=50, lbcnn_depth=2, learning_rate=1e-2, momentum=0.9, weight_d
     scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=lr_scheduler_step)
 
     for epoch in range(n_epochs):
-        scheduler.step()
         for batch_id, (inputs, labels) in enumerate(
                 tqdm(train_loader, desc="Epoch {}/{}".format(epoch, n_epochs))):
-            inputs = Variable(inputs)
-            labels = Variable(labels)
             if use_cuda:
                 inputs = inputs.cuda()
                 labels = labels.cuda()
@@ -58,15 +55,17 @@ def train(n_epochs=50, lbcnn_depth=2, learning_rate=1e-2, momentum=0.9, weight_d
             loss = criterion(outputs, labels)
             loss.backward()
             optimizer.step()
-        epoch_accuracy = calc_accuracy(model, loader=train_loader)
-        print("Epoch {} train accuracy: {:.3f}".format(epoch, epoch_accuracy))
-        if epoch_accuracy > best_accuracy:
-            best_accuracy = epoch_accuracy
+        accuracy_train = calc_accuracy(model, loader=train_loader)
+        accuracy_test = calc_accuracy(model, loader=test_loader)
+        print("Epoch {} accuracy: train={:.3f}, test={:.3f}".format(epoch, accuracy_train, accuracy_test))
+        if accuracy_train > best_accuracy:
+            best_accuracy = accuracy_train
             torch.save((lbcnn_depth, model.state_dict()), MODEL_PATH)
+        scheduler.step(epoch=epoch)
     train_duration_sec = int(time.time() - start)
     print('Finished Training. Total training time: {} sec'.format(train_duration_sec))
 
 
 if __name__ == '__main__':
+    # train includes test phase at each epoch
     train(n_epochs=5)
-    test()

requirements.txt

@@ -1,3 +1,3 @@
-pytorch==0.3.0
-torchvision==0.2.0
-tqdm==4.23.0
+pytorch==1.4.0
+torchvision==0.5.0
+tqdm

utils.py

@@ -2,7 +2,6 @@
 import torch.utils.data
 import torchvision
 import torchvision.transforms as transforms
-from torch.autograd import Variable
 from tqdm import tqdm
 
 
@@ -40,12 +39,13 @@ def calc_accuracy(model, loader, verbose=False):
         if use_cuda:
             inputs = inputs.cuda()
             labels = labels.cuda()
-        outputs_batch = model(Variable(inputs, volatile=True))
+        with torch.no_grad():
+            outputs_batch = model(inputs)
         outputs_full.append(outputs_batch)
         labels_full.append(labels)
     model.train(mode_saved)
     outputs_full = torch.cat(outputs_full, dim=0)
     labels_full = torch.cat(labels_full, dim=0)
     _, labels_predicted = torch.max(outputs_full.data, dim=1)
-    accuracy = torch.sum(labels_full == labels_predicted) / len(labels_full)
+    accuracy = torch.sum(labels_full == labels_predicted).item() / float(len(labels_full))
     return accuracy