fix typo

.gitignore

@@ -9,5 +9,4 @@ docs/html/
 encoding/lib/
 encoding/_ext/
 encoding.egg-info/
-experiments/recognition/
 experiments/segmentation/

docs/source/experiments/texture.rst

@@ -19,7 +19,7 @@ Test Pre-trained Model
 
     git clone git@github.com:zhanghang1989/PyTorch-Encoding.git
 
-- Download the `MINC-2500 <http://opensurfaces.cs.cornell.edu/publications/minc/>`_ dataset to ``$HOME/data/minc`` folder. Download pre-trained model (training `curve`_ as bellow, pre-trained on train-1 split using single training size of 224, with an error rate of :math:`19.98\%` using single crop on test-1 set)::
+- Download the `MINC-2500 <http://opensurfaces.cs.cornell.edu/publications/minc/>`_ dataset to ``$HOME/data/minc-2500/`` folder. Download pre-trained model (training `curve`_ as bellow, pre-trained on train-1 split using single training size of 224, with an error rate of :math:`19.98\%` using single crop on test-1 set)::
 
     cd PyTorch-Encoding/experiments
     bash model/download_models.sh
@@ -31,7 +31,7 @@ Test Pre-trained Model
 
 - Test pre-trained model on MINC-2500::
 
-    >>> python main.py --dataset minc --model encodingnet --resume model/minc.pth.tar --eval
+    >>> python main.py --dataset minc --model deepten --nclass 23 --resume model/minc.pth.tar --eval
     # Teriminal Output:
     #[======================================== 23/23 ===================================>...]    Step: 104ms | Tot: 3s256ms | Loss: 0.719 | Err: 19.983% (1149/5750) 
 
@@ -41,7 +41,7 @@ Train Your Own Model
 
 - Example training command for training above model::
 
-    python main.py --dataset minc --model encodingnet --batch-size 64 --lr 0.01 --epochs 60 
+    python main.py --model deepten --nclass 23 --model encodingnet --batch-size 64 --lr 0.01 --epochs 60 
 
 - Training options::
 

encoding/nn/encoding.py

@@ -93,8 +93,8 @@ def forward(self, X):
             X = X.view(B,D,-1).transpose(1,2).contiguous()
         else:
             raise RuntimeError('Encoding Layer unknown input dims!')
-        # assignment weights
-        A = F.softmax(scaledL2(X, self.codewords, self.scale), dim=2)
+        # assignment weights NxKxD
+        A = F.softmax(scaledL2(X, self.codewords, self.scale), dim=1)
         # aggregate
         E = aggregate(A, X, self.codewords)
         return E
@@ -146,7 +146,7 @@ def forward(self, X):
         # shake
         self.shake()
         # assignment weights
-        A = F.softmax(scaledL2(X, self.codewords, self.scale), dim=2)
+        A = F.softmax(scaledL2(X, self.codewords, self.scale), dim=1)
         # aggregate
         E = aggregate(A, X, self.codewords)
         # shake

encoding/utils.py

@@ -68,7 +68,7 @@ def __init__(self, args, niters=0):
             self.N = args.epochs * niters
         self.epoch = -1
 
-    def __call__(self, optimizer, i, epoch):
+    def __call__(self, optimizer, i, epoch, best_pred):
         if self.mode == 'cos':
             T = (epoch - 1) * self.niters + i
             lr = 0.5 * self.lr * (1 + math.cos(1.0 * T / self.N * math.pi))
@@ -80,8 +80,9 @@ def __call__(self, optimizer, i, epoch):
         else:
             raise RuntimeError('Unknown LR scheduler!')
         if epoch > self.epoch:
-            print('\n=>Epoches %i, learning rate = %.4f' % (
-                epoch, lr))
+            print('\n=>Epoches %i, learning rate = %.4f, \
+                previous best = %.4f' % (
+                epoch, lr, best_pred))
             self.epoch = epoch
         self._adjust_learning_rate(optimizer, lr)
 

experiments/main.py → experiments/recognition/main.py

@@ -10,6 +10,7 @@
 
 from __future__ import print_function
 
+import os
 import matplotlib.pyplot as plot
 import importlib
 
@@ -22,29 +23,13 @@
 from option import Options
 from encoding.utils import *
 
+from tqdm import tqdm
+
 # global variable
 best_pred = 100.0
 errlist_train = []
 errlist_val = []
 
-
-def adjust_learning_rate(optimizer, args, epoch, best_pred):
-    if epoch <= 60:
-        lr = args.lr * (0.1 ** ((epoch - 1) // 40))
-    else:
-        lr = 1e-4
-    print('=>Epochs %i, learning rate = %.4f, previous best = %.3f%%' % (
-		epoch, lr, best_pred))
-    if len(optimizer.param_groups) == 1:
-        optimizer.param_groups[0]['lr'] = lr
-    elif len(optimizer.param_groups) == 2:
-        # enlarge the lr at the head
-        optimizer.param_groups[0]['lr'] = lr
-        optimizer.param_groups[1]['lr'] = lr * 10
-    else:
-        raise RuntimeError('unsupported number of param groups: {}' \
-            .format(len(optimizer.param_groups)))
-
 def main():
     # init the args
     global best_pred, errlist_train, errlist_val
@@ -64,19 +49,15 @@ def main():
     train_loader, test_loader = Dataloder(args).getloader()
     # init the model
     models = importlib.import_module('model.'+args.model)
-    model = models.Net()
+    model = models.Net(args)
     print(model)
     # criterion and optimizer
     criterion = nn.CrossEntropyLoss()
-    optimizer = get_optimizer(args, model)
+    optimizer = get_optimizer(args, model, False)
     if args.cuda:
         model.cuda()
         # Please use CUDA_VISIBLE_DEVICES to control the number of gpus
         model = torch.nn.DataParallel(model)
-    """
-    optim.SGD(model.parameters(), lr=args.lr, momentum=
-            args.momentum, weight_decay=args.weight_decay)
-    """
     # check point
     if args.resume is not None:
         if os.path.isfile(args.resume):
@@ -93,14 +74,15 @@ def main():
         else:
             print("=> no resume checkpoint found at '{}'".\
                 format(args.resume))
-    #scheduler = CosLR_Scheduler(args, len(train_loader))
+    scheduler = LR_Scheduler(args, len(train_loader))
     def train(epoch):
         model.train()
         global best_pred, errlist_train
         train_loss, correct, total = 0,0,0
-        adjust_learning_rate(optimizer, args, epoch, best_pred)
-        for batch_idx, (data, target) in enumerate(train_loader):
-            #scheduler(optimizer, batch_idx, epoch, best_pred)
+        #adjust_learning_rate(optimizer, args, epoch, best_pred)
+        tbar = tqdm(train_loader, desc='\r')
+        for batch_idx, (data, target) in enumerate(tbar):
+            scheduler(optimizer, batch_idx, epoch, best_pred)
             if args.cuda:
                 data, target = data.cuda(), target.cuda()
             data, target = Variable(data), Variable(target)
@@ -115,18 +97,18 @@ def train(epoch):
             correct += pred.eq(target.data).cpu().sum()
             total += target.size(0)
             err = 100-100.*correct/total
-            progress_bar(batch_idx, len(train_loader), 
-                'Loss: %.3f | Err: %.3f%% (%d/%d)' % \
-                (train_loss/(batch_idx+1), 
-                err, total-correct, total))
+            tbar.set_description('\rLoss: %.3f | Err: %.3f%% (%d/%d)' % \
+                (train_loss/(batch_idx+1), err, total-correct, total))
+
         errlist_train += [err]
 
     def test(epoch):
         model.eval()
         global best_pred, errlist_train, errlist_val
         test_loss, correct, total = 0,0,0
         is_best = False
-        for batch_idx, (data, target) in enumerate(test_loader):
+        tbar = tqdm(test_loader, desc='\r')
+        for batch_idx, (data, target) in enumerate(tbar):
             if args.cuda:
                 data, target = data.cuda(), target.cuda()
             data, target = Variable(data, volatile=True), Variable(target)
@@ -138,10 +120,8 @@ def test(epoch):
             total += target.size(0)
 
             err = 100-100.*correct/total
-            progress_bar(batch_idx, len(test_loader), 
-                'Loss: %.3f | Err: %.3f%% (%d/%d)'% \
-                (test_loss/(batch_idx+1), 
-                err, total-correct, total))
+            tbar.set_description('Loss: %.3f | Err: %.3f%% (%d/%d)'% \
+                (test_loss/(batch_idx+1), err, total-correct, total))
 
         if args.eval:
             print('Error rate is %.3f'%err)

experiments/model/encodingnet.py → experiments/recognition/model/deepten.py

@@ -17,19 +17,19 @@
 import torchvision.models as resnet
 
 class Net(nn.Module):
-    def __init__(self, nclass=23, aux=False, backbone='resnet50'):
+    def __init__(self, args):
+        nclass=args.nclass
         super(Net, self).__init__()
-        self.backbone = backbone
+        self.backbone = args.backbone
         # copying modules from pretrained models
-        if backbone == 'resnet50':
+        if self.backbone == 'resnet50':
             self.pretrained = resnet.resnet50(pretrained=True)
-        elif backbone == 'resnet101':
+        elif self.backbone == 'resnet101':
             self.pretrained = resnet.resnet101(pretrained=True)
-        elif backbone == 'resnet152':
+        elif self.backbone == 'resnet152':
             self.pretrained = resnet.resnet152(pretrained=True)
         else:
-            raise RuntimeError('unknown backbone: {}'.format(backbone))
-        self.aux = aux
+            raise RuntimeError('unknown backbone: {}'.format(self.backbone))
         n_codes = 32
         self.head = nn.Sequential(
             nn.Conv2d(2048, 128, 1),
@@ -51,35 +51,13 @@ def forward(self, x):
             _, _, h, w = var_input.size()
         else:
             raise RuntimeError('unknown input type: ', type(x))
-
-        if self.backbone == 'resnet50' or self.backbone == 'resnet101' \
-            or self.backbone == 'resnet152':
-            # pre-trained ResNet feature
-            x = self.pretrained.conv1(x)
-            x = self.pretrained.bn1(x)
-            x = self.pretrained.relu(x)
-            x = self.pretrained.maxpool(x)
-            x = self.pretrained.layer1(x)
-            x = self.pretrained.layer2(x)
-            x = self.pretrained.layer3(x)
-            x = self.pretrained.layer4(x)
-        else:
-            x = self.pretrained(x)
+        x = self.pretrained.conv1(x)
+        x = self.pretrained.bn1(x)
+        x = self.pretrained.relu(x)
+        x = self.pretrained.maxpool(x)
+        x = self.pretrained.layer1(x)
+        x = self.pretrained.layer2(x)
+        x = self.pretrained.layer3(x)
+        x = self.pretrained.layer4(x)
         return self.head(x)
 
-
-def test():
-    net = Net(nclass=23).cuda()
-    print(net)
-    x = Variable(torch.randn(1,3,224,224)).cuda()
-    y = net(x)
-    print(y)
-    params = net.parameters()
-    sum = 0
-    for param in params:
-        sum += param.nelement()
-    print('Total params:', sum)
-
-
-if __name__ == "__main__":
-    test()

experiments/option.py → experiments/recognition/option.py

@@ -17,11 +17,15 @@ def __init__(self):
         parser = argparse.ArgumentParser(description='Deep Encoding')
         parser.add_argument('--dataset', type=str, default='cifar10',
             help='training dataset (default: cifar10)')
+        # model params 
         parser.add_argument('--model', type=str, default='densenet',
             help='network model type (default: densenet)')
-        # scale factor for HangsNet only
+        parser.add_argument('--nclass', type=int, default=10, metavar='N',
+            help='number of classes (default: 10)')
         parser.add_argument('--widen', type=int, default=4, metavar='N',
             help='widen factor of the network (default: 4)')
+        parser.add_argument('--backbone', type=str, default='resnet50',
+            help='backbone name (default: resnet50)')
         # training hyper params
         parser.add_argument('--batch-size', type=int, default=128,
             metavar='N', help='batch size for training (default: 128)')
@@ -31,12 +35,18 @@ def __init__(self):
             help='number of epochs to train (default: 300)')
         parser.add_argument('--start_epoch', type=int, default=1, 
             metavar='N', help='the epoch number to start (default: 0)')
+        # lr setting
         parser.add_argument('--lr', type=float, default=0.1, metavar='LR',
             help='learning rate (default: 0.1)')
+        parser.add_argument('--lr-scheduler', type=str, default='step', 
+            help='learning rate scheduler (default: step)')
+        parser.add_argument('--lr-step', type=int, default=40, metavar='LR',
+            help='learning rate step (default: 40)')
+        # optimizer
         parser.add_argument('--momentum', type=float, default=0.9, 
             metavar='M', help='SGD momentum (default: 0.9)')
-        parser.add_argument('--weight-decay', type=float, default=1e-4, 
-            metavar ='M', help='SGD weight decay (default: 1e-4)')
+        parser.add_argument('--weight-decay', type=float, default=5e-4, 
+            metavar ='M', help='SGD weight decay (default: 5e-4)')
         # cuda, seed and logging
         parser.add_argument('--no-cuda', action='store_true', 
             default=False, help='disables CUDA training')
@@ -53,5 +63,6 @@ def __init__(self):
         parser.add_argument('--eval', action='store_true', default= False,
             help='evaluating')
         self.parser = parser
+
     def parse(self):
         return self.parser.parse_args()