Question: Training performance over multiple training sessions.

[SergioRAgostinho]

Hi. I'm just looking for some feedback on your experience with variability in trained model quality between training sessions.

I'm progressively trying to retrace some important steps:

1. validating the paper results with the trained models you provided
2. training the models with the initial weights you provided and trying to achieve the same performance metrics as in the paper.
3. training the initial weights, then training new models with the new initial weights, and finally verifying the paper results.

An important disclaimer is that I had to apply the modifications in #30 in order to run things.

Step 1 seems to be working just fine. The difference between the results and the paper are within 5% give or take.

For Step 2, things are looking a little bit worse. My experiment was done training the ape object, which has a low ADD score compared to the other objects. With your models I manage to achieve an ADD score of roughly 28%, with my trained model it dropped significantly to 21%. I'm training the model once more to get a feeling for the performance variability between training sessions but decided to ask if this is normal and expected.

Thanks

[btekin]

Hello! Thanks for your interest in our work and modifying the code at #30 so that it can also work with Python3 and PyTorch 0.4.1. I didn't have much time yet to test all the modifications and merge it with the current version. About the training variability, one thing I can tell is that I had to retrain all the models for single object pose estimation after paper submission as I couldn't find the models used in the paper. The retrained models that we provide, as you also observed, do not change much from the initial results that we got (sometimes slight worse and sometimes slightly better). I wonder if the modifications that you have made has an influence on this. But in my experience, the current version of the code that works on PyTorch 0.3 and Python2 didn't have much variability over different training sessions.

[SergioRAgostinho]

Thanks for the feedback. I’m looking forward to your demo run of #30 just to understand if they had an impact. Goes without saying, the idea is to test those changes still under python 2.7 and pytorch 0.3.x.

Thanks for the quick reply and continuous support.

[SergioRAgostinho]

After training a second time with the same initial weights, the accuracy was the same as my previous training attempt. Practically zero, if not zero, variability in quality between training sessions. My ideas now reduce to:

• I messed up in Extend support to Python3 and PyTorch 0.4.1 #30
• Having a lower batch size (4) is affecting the quality of my solution. I believe it shouldn't but it's less samples used to compute the gradient direction so who knows... Maybe it needs more epochs.

Basically I need your feedback to validate all of these hypotheses.

[btekin]

Among the two possibilities, one problem might indeed be related to the batch size. In the YOLOv2 detection code, the learning rate is adjusted according to the batch size, and we follow the same approach. A very small batch size, in this case, makes the learning rate bigger. This might be one of the reasons for the lower accuracy that you get. Could you by any chance try with a larger batch size?

[SergioRAgostinho]

In the YOLOv2 detection code, the learning rate is adjusted according to the batch size, and we follow the same approach: . A very small batch size, in this case, makes the learning rate bigger. This might be one of the reasons for the lower accuracy that you get.

Thanks for the tip. That adjustment is made below correct?
https://github.com/Microsoft/singleshotpose/blob/1e6bfae97ee8e307abd3d06bf062b33f5d713af4/train.py#L386

Could you by any chance try with a larger batch size?

Not really, my gpu will run out of memory :/

I'll try lowering the learning rate and see how it goes.

[btekin]

Thanks for the tip. That adjustment is made below correct?

Yes, that's indeed the case.

I made some modifications to the network and tried it with Python 3.6 & PyTorch 0.4. I seem to have consistent results with Python 2 and PyTorch 0.3. I took a look at your code and only differences with mine seem to be in these lines:

https://github.com/SergioRAgostinho/singleshotpose/blob/master/darknet.py#L149
https://github.com/SergioRAgostinho/singleshotpose/blob/master/cfg.py#L56LL58
https://github.com/SergioRAgostinho/singleshotpose/blob/master/cfg.py#L69:L70
https://github.com/SergioRAgostinho/singleshotpose/blob/master/cfg.py#L101:L102

where I used floor division (//) instead of standard division (/). I still didn't test for backward compatibility though. Could you also confirm if these changes work for you?

[SergioRAgostinho]

Could you also confirm if these changes work for you?

Do you mind producing a diff or just push the changes somewhere (your own private fork?) and I'll clone them. Just to prevent human error in the loop :)

I used floor division (//) instead of standard division (/). I still didn't test for backward compatibility though.

It should work exactly the same.

On other news after some experiments I validated that the batch size influences a lot the quality of the results. I was only able to run things with a batch size of 8 in a GTX 1080 and the results got much closer to yours. If the batch size is reduced to anything below that, the quality of the training suffers a lot.

[btekin]

On other news after some experiments I validated that the batch size influences a lot the quality of the results. I was only able to run things with a batch size of 8 in a GTX 1080 and the results got much closer to yours. If the batch size is reduced to anything below that, the quality of the training suffers a lot.

Ok, good news, that makes sense. As the learning rate is divided by the batch size, this might be crucial.

It should work exactly the same.

Yes, that's true, then actually the only difference is the batch size (I tried it with a batch size of 32).

You could take take a look at my fork for the code: https://github.com/btekin/singleshot6Dpose

[SergioRAgostinho]

Ok, good news, that makes sense. As the learning rate is divided by the batch size, this might be crucial.

It didn't really feel like it was a learning rate issue because I actually tried a couple higher and lower rates just to get a feel for the effect. My only conjecture was that maybe the gradient direction is just "too arbitrary" with a lower number of samples. I did nothing else to actually validate the theory though.

You could take take a look at my fork for the code: https://github.com/btekin/singleshot6Dpose

Thanks. I'll report back with results. Do you want me to push your new changes to #30 in case they're ok?

[SergioRAgostinho]

My first run of your fork master branch as is (but with batch size 8) aborted early halfway through epoch 17.

The requested command:
python3 /home/sergio/Development/3rdparty/singleshotpose/train.py cfg/eggbox.data cfg/yolo-pose.cfg backup/eggbox/init.weights
aborted with the error code 1.
Traceback (most recent call last):
  File "/home/sergio/Development/3rdparty/singleshotpose/train.py", line 400, in <module>
    niter = train(epoch)
  File "/home/sergio/Development/3rdparty/singleshotpose/train.py", line 89, in train
    output = model(data)
  File "/home/sergio/.local/lib/python3.6/site-packages/torch/nn/modules/module.py", line 477, in __call__
    result = self.forward(*input, **kwargs)
  File "/home/sergio/Development/3rdparty/singleshotpose/darknet.py", line 91, in forward
    x = self.models[ind](x)
  File "/home/sergio/.local/lib/python3.6/site-packages/torch/nn/modules/module.py", line 477, in __call__
    result = self.forward(*input, **kwargs)
  File "/home/sergio/Development/3rdparty/singleshotpose/darknet.py", line 27, in forward
    assert(H % stride == 0)
AssertionError

Seems like you changed a little bit more than you originally reported 😅 . This is the diff between my PR in #30 and your fork.

Edit: seem to be minor things, except for that hardcoded 32 which is now modifiable by the batch size. That's the only thing which might be different between our runs.

Diff Report (click to uncollapse)

diff --git a/cfg.py b/cfg.py
index bfc68e4..71f78eb 100644
--- a/cfg.py
+++ b/cfg.py
@@ -53,9 +53,9 @@ def print_cfg(blocks):
             kernel_size = int(block['size'])
             stride = int(block['stride'])
             is_pad = int(block['pad'])
-            pad = (kernel_size-1)/2 if is_pad else 0
-            width = (prev_width + 2*pad - kernel_size)/stride + 1
-            height = (prev_height + 2*pad - kernel_size)/stride + 1
+            pad = (kernel_size-1)//2 if is_pad else 0
+            width = (prev_width + 2*pad - kernel_size)//stride + 1
+            height = (prev_height + 2*pad - kernel_size)//stride + 1
             print('%5d %-6s %4d  %d x %d / %d   %3d x %3d x%4d   ->   %3d x %3d x%4d' % (ind, 'conv', filters, kernel_size, kernel_size, stride, prev_width, prev_height, prev_filters, width, height, filters))
             prev_width = width
             prev_height = height
@@ -66,8 +66,8 @@ def print_cfg(blocks):
         elif block['type'] == 'maxpool':
             pool_size = int(block['size'])
             stride = int(block['stride'])
-            width = prev_width/stride
-            height = prev_height/stride
+            width = prev_width//stride
+            height = prev_height//stride
             print('%5d %-6s       %d x %d / %d   %3d x %3d x%4d   ->   %3d x %3d x%4d' % (ind, 'max', pool_size, pool_size, stride, prev_width, prev_height, prev_filters, width, height, filters))
             prev_width = width
             prev_height = height
@@ -98,8 +98,8 @@ def print_cfg(blocks):
         elif block['type'] == 'reorg':
             stride = int(block['stride'])
             filters = stride * stride * prev_filters
-            width = prev_width/stride
-            height = prev_height/stride
+            width = prev_width//stride
+            height = prev_height//stride
             print('%5d %-6s             / %d   %3d x %3d x%4d   ->   %3d x %3d x%4d' % (ind, 'reorg', stride, prev_width, prev_height, prev_filters, width, height, filters))
             prev_width = width
             prev_height = height
@@ -172,7 +172,7 @@ def load_conv_bn(buf, start, conv_model, bn_model):
     bn_model.weight.data.copy_(torch.from_numpy(buf[start:start+num_b]));   start = start + num_b
     bn_model.running_mean.copy_(torch.from_numpy(buf[start:start+num_b]));  start = start + num_b
     bn_model.running_var.copy_(torch.from_numpy(buf[start:start+num_b]));   start = start + num_b
-    conv_model.weight.data.copy_(torch.from_numpy(buf[start:start+num_w]).view_as(conv_model.weight.data)); start = start + num_w
+    conv_model.weight.data.copy_(torch.from_numpy(buf[start:start+num_w]).view_as(conv_model.weight.data)); start = start + num_w 
     return start
 
 def save_conv_bn(fp, conv_model, bn_model):
@@ -193,7 +193,7 @@ def load_fc(buf, start, fc_model):
     num_w = fc_model.weight.numel()
     num_b = fc_model.bias.numel()
     fc_model.bias.data.copy_(torch.from_numpy(buf[start:start+num_b]));     start = start + num_b
-    fc_model.weight.data.copy_(torch.from_numpy(buf[start:start+num_w]).view_as(fc_model.weight.data));   start = start + num_w
+    fc_model.weight.data.copy_(torch.from_numpy(buf[start:start+num_w]).view_as(fc_model.weight.data));   start = start + num_w 
     return start
 
 def save_fc(fp, fc_model):
diff --git a/darknet.py b/darknet.py
index e5cb5dd..471a862 100644
--- a/darknet.py
+++ b/darknet.py
@@ -227,10 +227,13 @@ class Darknet(nn.Module):
             elif block['type'] == 'region':
                 loss = RegionLoss()
                 anchors = block['anchors'].split(',')
-                loss.anchors = [float(i) for i in anchors]
+                if anchors == ['']:
+                    loss.anchors = []
+                else:
+                    loss.anchors = [float(i) for i in anchors]
                 loss.num_classes = int(block['classes'])
                 loss.num_anchors = int(block['num'])
-                loss.anchor_step = len(loss.anchors)/loss.num_anchors
+                loss.anchor_step = len(loss.anchors)//loss.num_anchors
                 loss.object_scale = float(block['object_scale'])
                 loss.noobject_scale = float(block['noobject_scale'])
                 loss.class_scale = float(block['class_scale'])
diff --git a/dataset.py b/dataset.py
index 4d62e0c..9c75915 100644
--- a/dataset.py
+++ b/dataset.py
@@ -14,12 +14,27 @@ from utils import read_truths_args, read_truths, get_all_files
 class listDataset(Dataset):
 
     def __init__(self, root, shape=None, shuffle=True, transform=None, target_transform=None, train=False, seen=0, batch_size=64, num_workers=4, bg_file_names=None):
+
+      # root             : list of training or test images
+      # shape            : shape of the image input to the network
+      # shuffle          : whether to shuffle or not 
+      # tranform         : any pytorch-specific transformation to the input image 
+      # target_transform : any pytorch-specific tranformation to the target output
+      # train            : whether it is training data or test data
+      # seen             : the number of visited examples (iteration of the batch x batch size) # TODO: check if this is correctly assigned
+      # batch_size       : how many examples there are in the batch
+      # num_workers      : check what this is
+      # bg_file_names    : the filenames for images from which you assign random backgrounds
+
+       # read the the list of dataset images
        with open(root, 'r') as file:
            self.lines = file.readlines()
 
+       # Shuffle
        if shuffle:
            random.shuffle(self.lines)
 
+       # Initialize variables
        self.nSamples         = len(self.lines)
        self.transform        = transform
        self.target_transform = target_transform
@@ -30,39 +45,48 @@ class listDataset(Dataset):
        self.num_workers      = num_workers
        self.bg_file_names    = bg_file_names
 
+    # Get the number of samples in the dataset
     def __len__(self):
         return self.nSamples
 
+    # Get a sample from the dataset
     def __getitem__(self, index):
+
+        # Ensure the index is smallet than the number of samples in the dataset, otherwise return error
         assert index <= len(self), 'index range error'
+
+        # Get the image path
         imgpath = self.lines[index].rstrip()
 
-        if self.train and index % 32== 0:
-            if self.seen < 400*32:
-               width = 13*32
+        # Decide which size you are going to resize the image depending on the iteration
+        if self.train and index % self.batch_size== 0:
+            if self.seen < 400*self.batch_size:
+               width = 13*self.batch_size
                self.shape = (width, width)
-            elif self.seen < 800*32:
-               width = (random.randint(0,7) + 13)*32
+            elif self.seen < 800*self.batch_size:
+               width = (random.randint(0,7) + 13)*self.batch_size
                self.shape = (width, width)
-            elif self.seen < 1200*32:
-               width = (random.randint(0,9) + 12)*32
+            elif self.seen < 1200*self.batch_size:
+               width = (random.randint(0,9) + 12)*self.batch_size
                self.shape = (width, width)
-            elif self.seen < 1600*32:
-               width = (random.randint(0,11) + 11)*32
+            elif self.seen < 1600*self.batch_size:
+               width = (random.randint(0,11) + 11)*self.batch_size
                self.shape = (width, width)
-            elif self.seen < 2000*32:
-               width = (random.randint(0,13) + 10)*32
+            elif self.seen < 2000*self.batch_size:
+               width = (random.randint(0,13) + 10)*self.batch_size
                self.shape = (width, width)
-            elif self.seen < 2400*32:
-               width = (random.randint(0,15) + 9)*32
+            elif self.seen < 2400*self.batch_size:
+               width = (random.randint(0,15) + 9)*self.batch_size
                self.shape = (width, width)
-            elif self.seen < 3000*32:
-               width = (random.randint(0,17) + 8)*32
+            elif self.seen < 3000*self.batch_size:
+               width = (random.randint(0,17) + 8)*self.batch_size
                self.shape = (width, width)
-            else: # self.seen < 20000*64:
-               width = (random.randint(0,19) + 7)*32
+            else: 
+               width = (random.randint(0,19) + 7)*self.batch_size
                self.shape = (width, width)
+
         if self.train:
+            # If you are going to train, decide on how much data augmentation you are going to apply
             jitter = 0.2
             hue = 0.1
             saturation = 1.5 
@@ -70,20 +94,26 @@ class listDataset(Dataset):
 
             # Get background image path
             random_bg_index = random.randint(0, len(self.bg_file_names) - 1)
-            bgpath = self.bg_file_names[random_bg_index]
+            bgpath = self.bg_file_names[random_bg_index]    
 
+            # Get the data augmented image and their corresponding labels
             img, label = load_data_detection(imgpath, self.shape, jitter, hue, saturation, exposure, bgpath)
+
+            # Convert the labels to PyTorch variables
             label = torch.from_numpy(label)
+        
         else:
+            # Get the validation image, resize it to the network input size
             img = Image.open(imgpath).convert('RGB')
             if self.shape:
                 img = img.resize(self.shape)
     
+            # Read the validation labels, allow upto 50 ground-truth objects in an image
             labpath = imgpath.replace('images', 'labels').replace('JPEGImages', 'labels').replace('.jpg', '.txt').replace('.png','.txt')
             label = torch.zeros(50*21)
             if os.path.getsize(labpath):
                 ow, oh = img.size
-                tmp = torch.from_numpy(read_truths_args(labpath, 8.0/ow))
+                tmp = torch.from_numpy(read_truths_args(labpath))
                 tmp = tmp.view(-1)
                 tsz = tmp.numel()
                 if tsz > 50*21:
@@ -91,11 +121,16 @@ class listDataset(Dataset):
                 elif tsz > 0:
                     label[0:tsz] = tmp
 
+        # Tranform the image data to PyTorch tensors
         if self.transform is not None:
             img = self.transform(img)
 
+        # If there is any PyTorch-specific transformation, transform the label data
         if self.target_transform is not None:
             label = self.target_transform(label)
 
+        # Increase the number of seen examples
         self.seen = self.seen + self.num_workers
+
+        # Return the retrieved image and its corresponding label
         return (img, label)
diff --git a/region_loss.py b/region_loss.py
index 1e0548a..2241dea 100644
--- a/region_loss.py
+++ b/region_loss.py
@@ -10,7 +10,7 @@ def build_targets(pred_corners, target, anchors, num_anchors, num_classes, nH, n
     nB = target.size(0)
     nA = num_anchors
     nC = num_classes
-    anchor_step = len(anchors)/num_anchors
+    anchor_step = len(anchors)//num_anchors
     conf_mask   = torch.ones(nB, nA, nH, nW) * noobject_scale
     coord_mask  = torch.zeros(nB, nA, nH, nW)
     cls_mask    = torch.zeros(nB, nA, nH, nW)
@@ -156,7 +156,7 @@ class RegionLoss(nn.Module):
         self.num_classes = num_classes
         self.anchors = anchors
         self.num_anchors = num_anchors
-        self.anchor_step = len(anchors)/num_anchors
+        self.anchor_step = len(anchors)//num_anchors
         self.coord_scale = 1
         self.noobject_scale = 1
         self.object_scale = 5
@@ -175,8 +175,8 @@ class RegionLoss(nn.Module):
 
         # Activation
         output = output.view(nB, nA, (19+nC), nH, nW)
-        x0     = F.sigmoid(output.index_select(2, Variable(torch.cuda.LongTensor([0]))).view(nB, nA, nH, nW))
-        y0     = F.sigmoid(output.index_select(2, Variable(torch.cuda.LongTensor([1]))).view(nB, nA, nH, nW))
+        x0     = torch.sigmoid(output.index_select(2, Variable(torch.cuda.LongTensor([0]))).view(nB, nA, nH, nW))
+        y0     = torch.sigmoid(output.index_select(2, Variable(torch.cuda.LongTensor([1]))).view(nB, nA, nH, nW))
         x1     = output.index_select(2, Variable(torch.cuda.LongTensor([2]))).view(nB, nA, nH, nW)
         y1     = output.index_select(2, Variable(torch.cuda.LongTensor([3]))).view(nB, nA, nH, nW)
         x2     = output.index_select(2, Variable(torch.cuda.LongTensor([4]))).view(nB, nA, nH, nW)
@@ -193,7 +193,7 @@ class RegionLoss(nn.Module):
         y7     = output.index_select(2, Variable(torch.cuda.LongTensor([15]))).view(nB, nA, nH, nW)
         x8     = output.index_select(2, Variable(torch.cuda.LongTensor([16]))).view(nB, nA, nH, nW)
         y8     = output.index_select(2, Variable(torch.cuda.LongTensor([17]))).view(nB, nA, nH, nW)
-        conf   = F.sigmoid(output.index_select(2, Variable(torch.cuda.LongTensor([18]))).view(nB, nA, nH, nW))
+        conf   = torch.sigmoid(output.index_select(2, Variable(torch.cuda.LongTensor([18]))).view(nB, nA, nH, nW))
         cls    = output.index_select(2, Variable(torch.linspace(19,19+nC-1,nC).long().cuda()))
         cls    = cls.view(nB*nA, nC, nH*nW).transpose(1,2).contiguous().view(nB*nA*nH*nW, nC)
         t1     = time.time()
@@ -202,24 +202,24 @@ class RegionLoss(nn.Module):
         pred_corners = torch.cuda.FloatTensor(18, nB*nA*nH*nW)
         grid_x = torch.linspace(0, nW-1, nW).repeat(nH,1).repeat(nB*nA, 1, 1).view(nB*nA*nH*nW).cuda()
         grid_y = torch.linspace(0, nH-1, nH).repeat(nW,1).t().repeat(nB*nA, 1, 1).view(nB*nA*nH*nW).cuda()
-        pred_corners[0]  = (x0.data.view(-1) + grid_x) / nW
-        pred_corners[1]  = (y0.data.view(-1) + grid_y) / nH
-        pred_corners[2]  = (x1.data.view(-1) + grid_x) / nW
-        pred_corners[3]  = (y1.data.view(-1) + grid_y) / nH
-        pred_corners[4]  = (x2.data.view(-1) + grid_x) / nW
-        pred_corners[5]  = (y2.data.view(-1) + grid_y) / nH
-        pred_corners[6]  = (x3.data.view(-1) + grid_x) / nW
-        pred_corners[7]  = (y3.data.view(-1) + grid_y) / nH
-        pred_corners[8]  = (x4.data.view(-1) + grid_x) / nW
-        pred_corners[9]  = (y4.data.view(-1) + grid_y) / nH
-        pred_corners[10]  = (x5.data.view(-1) + grid_x) / nW
-        pred_corners[11]  = (y5.data.view(-1) + grid_y) / nH
-        pred_corners[12] = (x6.data.view(-1) + grid_x) / nW
-        pred_corners[13] = (y6.data.view(-1) + grid_y) / nH
-        pred_corners[14] = (x7.data.view(-1) + grid_x) / nW
-        pred_corners[15] = (y7.data.view(-1) + grid_y) / nH
-        pred_corners[16] = (x8.data.view(-1) + grid_x) / nW
-        pred_corners[17] = (y8.data.view(-1) + grid_y) / nH
+        pred_corners[0]  = (x0.data.view_as(grid_x) + grid_x) / nW
+        pred_corners[1]  = (y0.data.view_as(grid_y) + grid_y) / nH
+        pred_corners[2]  = (x1.data.view_as(grid_x) + grid_x) / nW
+        pred_corners[3]  = (y1.data.view_as(grid_y) + grid_y) / nH
+        pred_corners[4]  = (x2.data.view_as(grid_x) + grid_x) / nW
+        pred_corners[5]  = (y2.data.view_as(grid_y) + grid_y) / nH
+        pred_corners[6]  = (x3.data.view_as(grid_x) + grid_x) / nW
+        pred_corners[7]  = (y3.data.view_as(grid_y) + grid_y) / nH
+        pred_corners[8]  = (x4.data.view_as(grid_x) + grid_x) / nW
+        pred_corners[9]  = (y4.data.view_as(grid_y) + grid_y) / nH
+        pred_corners[10] = (x5.data.view_as(grid_x) + grid_x) / nW
+        pred_corners[11] = (y5.data.view_as(grid_y) + grid_y) / nH
+        pred_corners[12] = (x6.data.view_as(grid_x) + grid_x) / nW
+        pred_corners[13] = (y6.data.view_as(grid_y) + grid_y) / nH
+        pred_corners[14] = (x7.data.view_as(grid_x) + grid_x) / nW
+        pred_corners[15] = (y7.data.view_as(grid_y) + grid_y) / nH
+        pred_corners[16] = (x8.data.view_as(grid_x) + grid_x) / nW
+        pred_corners[17] = (y8.data.view_as(grid_y) + grid_y) / nH
         gpu_matrix = pred_corners.transpose(0,1).contiguous().view(-1,18)
         pred_corners = convert2cpu(gpu_matrix)
         t2 = time.time()
diff --git a/train.py b/train.py
index f2b86cb..20378fb 100644
--- a/train.py
+++ b/train.py
@@ -21,6 +21,9 @@ from region_loss import RegionLoss
 from darknet import Darknet
 from MeshPly import MeshPly
 
+import warnings
+warnings.filterwarnings("ignore")
+
 # Create new directory
 def makedirs(path):
     if not os.path.exists( path ):
@@ -50,12 +53,12 @@ def train(epoch):
 
     # Get the dataloader for training dataset
     train_loader = torch.utils.data.DataLoader(dataset.listDataset(trainlist, shape=(init_width, init_height),
-                                                            shuffle=True,
-                                                            transform=transforms.Compose([transforms.ToTensor(),]), 
-                                                            train=True, 
-                                                            seen=model.seen,
-                                                            batch_size=batch_size,
-                                                            num_workers=num_workers, bg_file_names=bg_file_names),
+                                                                  shuffle=True,
+                                                                  transform=transforms.Compose([transforms.ToTensor(),]), 
+                                                                  train=True, 
+                                                                  seen=model.seen,
+                                                                  batch_size=batch_size,
+                                                                  num_workers=num_workers, bg_file_names=bg_file_names),
                                                 batch_size=batch_size, shuffle=False, **kwargs)
 
     # TRAINING
@@ -173,7 +176,7 @@ def test(epoch, niter):
             boxes   = all_boxes[i]
             # For each image, get all the targets (for multiple object pose estimation, there might be more than 1 target per image)
             truths  = target[i].view(-1, 21)
-            # Get how many object are present in the scene
+            # Get how many objects are present in the scene
             num_gts = truths_length(truths)
 
             # Iterate through each ground-truth object
@@ -288,7 +291,7 @@ if __name__ == "__main__":
     testlist      = data_options['valid']
     nsamples      = file_lines(trainlist)
     gpus          = data_options['gpus']  # e.g. 0,1,2,3
-    gpus = '0'
+    gpus                 = '0'
     meshname      = data_options['mesh']
     num_workers   = int(data_options['num_workers'])
     backupdir     = data_options['backup']
@@ -338,12 +341,12 @@ if __name__ == "__main__":
     model.seen = 0
     region_loss.iter  = model.iter
     region_loss.seen  = model.seen
-    processed_batches = model.seen/batch_size
+    processed_batches = model.seen//batch_size
     init_width        = model.width
     init_height       = model.height
     test_width        = 672
     test_height       = 672
-    init_epoch        = model.seen//nsamples
+    init_epoch        = model.seen//nsamples 
 
     # Variable to save
     training_iters          = []
@@ -365,10 +368,11 @@ if __name__ == "__main__":
     kwargs = {'num_workers': num_workers, 'pin_memory': True} if use_cuda else {}
 
     # Get the dataloader for test data
-    test_loader = torch.utils.data.DataLoader(dataset.listDataset(testlist, shape=(test_width, test_height),
-                                                                           shuffle=False,
-                                                                           transform=transforms.Compose([transforms.ToTensor(),]), 
-                                                                           train=False),
+    test_loader = torch.utils.data.DataLoader(dataset.listDataset(testlist, 
+                                                                                                                         shape=(test_width, test_height),
+                                                                  shuffle=False,
+                                                                  transform=transforms.Compose([transforms.ToTensor(),]), 
+                                                                  train=False),
                                              batch_size=1, shuffle=False, **kwargs)
 
     # Pass the model to GPU
diff --git a/utils.py b/utils.py
index af074f6..bbeb3c4 100644
--- a/utils.py
+++ b/utils.py
@@ -484,7 +484,7 @@ def get_region_boxes(output, conf_thresh, num_classes, only_objectness=1, valida
 def get_corresponding_region_boxes(output, conf_thresh, num_classes, anchors, num_anchors, correspondingclass, only_objectness=1, validation=False):
     
     # Parameters
-    anchor_step = len(anchors)/num_anchors
+    anchor_step = len(anchors)//num_anchors
     if output.dim() == 3:
         output = output.unsqueeze(0)
     batch = output.size(0)
@@ -889,7 +889,7 @@ def read_truths(lab_path):
     else:
         return np.array([])
 
-def read_truths_args(lab_path, min_box_scale):
+def read_truths_args(lab_path):
     truths = read_truths(lab_path)
     new_truths = []
     for i in range(truths.shape[0]):
(END)

[btekin]

Yes, they were only some additional comments and minor changes in the organization of the code. There was a mistake in dataset.py though (self.batch_size variable should be replaced with self.cell_size, see https://github.com/btekin/singleshot6Dpose/blob/master/dataset.py#L65). You could take a look at the latest commit in my branch. I tried it with a batch size of 8 and it seems to work well and reaches the accuracy of Python 2 & Pytorch 0.3 version. I cannot test backward compatibility with Python 2.7 though as now I work on a Windows machine and PyTorch does not support Python 2 on Windows.

[SergioRAgostinho]

I cannot test backward compatibility with Python 2.7 though as now I work on a Windows machine and PyTorch does not support Python 2 on Windows.

Let me first try things on my current setup if that's running I'll set up a virtual environment to validate the backwards compatibility.

[SergioRAgostinho]

Python3.6 with Pytorch 0.4.1

2018-09-27 14:53:09    Testing glue-tekin...
2018-09-27 14:53:09    Number of test samples: 1036
-----------------------------------
  tensor to cuda : 0.000603
         predict : 0.002860
get_region_boxes : 0.010186
            eval : 0.019931
           total : 0.033580
-----------------------------------
2018-09-27 14:54:02 Results of glue-tekin
2018-09-27 14:54:02    Acc using 5 px 2D Projection = 93.44%
2018-09-27 14:54:02    Acc using 10% threshold - 0.0176 vx 3D Transformation = 37.55%
2018-09-27 14:54:02    Acc using 5 cm 5 degree metric = 36.58%
2018-09-27 14:54:02    Mean 2D pixel error is 2.942649, Mean vertex error is 0.038165, mean corner error is 4.249682
2018-09-27 14:54:02    Translation error: 0.037826 m, angle error: 6.572973 degree, pixel error:  2.942649 pix

Python2.7 with Pytorch 0.3.1

2018-09-27 14:57:12    Testing glue...
2018-09-27 14:57:12    Number of test samples: 1036
-----------------------------------
  tensor to cuda : 0.000593
         predict : 0.002144
get_region_boxes : 0.015319
            eval : 0.002101
           total : 0.020157
-----------------------------------
2018-09-27 14:59:04 Results of glue
2018-09-27 14:59:04    Acc using 5 px 2D Projection = 94.98%
2018-09-27 14:59:04    Acc using 10% threshold - 0.0176 vx 3D Transformation = 30.41%
2018-09-27 14:59:04    Acc using 5 cm 5 degree metric = 38.61%
2018-09-27 14:59:04    Mean 2D pixel error is 2.997156, Mean vertex error is 0.040384, mean corner error is 4.302478
2018-09-27 14:59:04    Translation error: 0.040114 m, angle error: 6.286397 degree, pixel error:  2.997156 pix

Edit: Hmm. Not sure what to make of this. The second accuracy metric clearly got a little worse. I did generate a different cfg file to not overwrite previous results. But that one was used for the python3 test cases and it performed apparently better.

Other random facts:
There's a notorious difference in CPU consumption when I ran things with Python3.6 with Pytorch 0.4.1 vs Python2.7 with Pytorch 0.3.1. The first is much faster to start but it chokes the cpu completely, the second takes a lot to start but behaves normally and sticks itself to a single core.

[btekin]

I see, this might have to do with the performance difference on multiple training sessions. For how long did you train the network?

Other random facts:
There's a notorious difference in CPU consumption when I ran things with Python3.6 with Pytorch 0.4.1 vs Python2.7 with Pytorch 0.3.1. The first is much faster to start but it chokes the cpu completely, the second takes a lot to start but behaves normally and sticks itself to a single core.

It's interesting, the number of workers should be the same for both versions but maybe it's good to check again if it is indeed the case.

[SergioRAgostinho]

I see, this might have to do with the performance difference on multiple training sessions. For how long did you train the network?

It might, but I remember doing that experiment early on when I first opened this issue and managed to get almost the same accuracy as before. We can always try to retrain a couple of times and see if things change much.

The Python3 session was timed properly and lasted 1h57m. I didn't time the Python2 session.