Bump pytorch to 4.1 (ruotianluo#70)

* Update to pytorch4.1

* Refactor

Author: dmitriy-serdyuk

dataloader.py

@@ -204,6 +204,11 @@ def __len__(self):
         return len(self.info['images'])
 
 
+class ArraySampler(data.sampler.SubsetRandomSampler):
+    def __iter__(self):
+        return iter(self.indices)
+
+
 class BlobFetcher():
     """Experimental class for prefetching blobs in a separate process."""
     def __init__(self, split, dataloader, if_shuffle=False):
@@ -225,7 +230,8 @@ def reset(self):
          the get_minibatch_inds already.
         """
         # batch_size is 0, the merge is done in DataLoader class
-        sampler = self.dataloader.split_ix[self.split][self.dataloader.iterators[self.split]:]
+        sampler = ArraySampler(
+            self.dataloader.split_ix[self.split][self.dataloader.iterators[self.split]:])
         self.split_loader = iter(
             data.DataLoader(dataset=self.dataloader,
                             batch_size=1,

eval_utils.py

@@ -85,21 +85,24 @@ def eval_split(model, crit, loader, eval_kwargs={}):
         if data.get('labels', None) is not None:
             # forward the model to get loss
             tmp = [data['fc_feats'], data['att_feats'], data['labels'], data['masks']]
-            tmp = [Variable(torch.from_numpy(_), volatile=True).cuda() for _ in tmp]
-            fc_feats, att_feats, labels, masks = tmp
+            with torch.no_grad():
+                tmp = [Variable(torch.from_numpy(_)).cuda() for _ in tmp]
+                fc_feats, att_feats, labels, masks = tmp
 
-            loss = crit(model(fc_feats, att_feats, labels), labels[:,1:], masks[:,1:]).data[0]
+                loss = crit(model(fc_feats, att_feats, labels), labels[:,1:], masks[:,1:]).item()
             loss_sum = loss_sum + loss
             loss_evals = loss_evals + 1
 
         # forward the model to also get generated samples for each image
         # Only leave one feature for each image, in case duplicate sample
         tmp = [data['fc_feats'][np.arange(loader.batch_size) * loader.seq_per_img], 
             data['att_feats'][np.arange(loader.batch_size) * loader.seq_per_img]]
-        tmp = [Variable(torch.from_numpy(_), volatile=True).cuda() for _ in tmp]
-        fc_feats, att_feats = tmp
-        # forward the model to also get generated samples for each image
-        seq, _ = model.sample(fc_feats, att_feats, eval_kwargs)
+        with torch.no_grad():
+            tmp = [Variable(torch.from_numpy(_)).cuda() for _ in tmp]
+            fc_feats, att_feats = tmp
+            # forward the model to also get generated samples for each image
+            seq, _ = model.sample(fc_feats, att_feats, eval_kwargs)
+        seq = seq.cpu().numpy()
 
         #set_trace()
         sents = utils.decode_sequence(loader.get_vocab(), seq)

misc/utils.py

@@ -15,7 +15,7 @@ def if_use_att(caption_model):
 
 # Input: seq, N*D numpy array, with element 0 .. vocab_size. 0 is END token.
 def decode_sequence(ix_to_word, seq):
-    N, D = seq.size()
+    N, D = seq.shape
     out = []
     for i in range(N):
         txt = ''
@@ -42,9 +42,9 @@ def __init__(self):
 
     def forward(self, input, target, mask):
         # truncate to the same size
-        target = target[:, :input.size(1)]
-        mask =  mask[:, :input.size(1)]
-        input = to_contiguous(input).view(-1, input.size(2))
+        target = target[:, :input.shape[1]]
+        mask =  mask[:, :input.shape[1]]
+        input = to_contiguous(input).view(-1, input.shape[2])
         target = to_contiguous(target).view(-1, 1)
         mask = to_contiguous(mask).view(-1, 1)
         output = - input.gather(1, target) * mask
@@ -59,4 +59,4 @@ def set_lr(optimizer, lr):
 def clip_gradient(optimizer, grad_clip):
     for group in optimizer.param_groups:
         for param in group['params']:
-            param.grad.data.clamp_(-grad_clip, grad_clip)
+            param.grad.data.clamp_(-grad_clip, grad_clip)

scripts/prepro_feats.py

@@ -80,17 +80,20 @@ def main(params):
 
       I = I.astype('float32')/255.0
       I = torch.from_numpy(I.transpose([2,0,1])).cuda()
-      I = Variable(preprocess(I), volatile=True)
-      tmp_fc, tmp_att = my_resnet(I, params['att_size'])
-      # write to hdf5
-
-      d_set_fc = file_fc.create_dataset(str(img['cocoid']), 
-        (2048,), dtype="float")
-      d_set_att = file_att.create_dataset(str(img['cocoid']), 
-        (params['att_size'], params['att_size'], 2048), dtype="float")
+      with torch.no_grad():
+          I = Variable(preprocess(I))
+          tmp_fc, tmp_att = my_resnet(I, params['att_size'])
 
-      d_set_fc[...] = tmp_fc.data.cpu().float().numpy()
-      d_set_att[...] = tmp_att.data.cpu().float().numpy()
+      # write to hdf5
+      d_set_fc = file_fc.create_dataset(
+          str(img['cocoid']), 
+          (2048,), dtype="float")
+      d_set_att = file_att.create_dataset(
+          str(img['cocoid']), 
+          (params['att_size'], params['att_size'], 2048), dtype="float")
+
+      d_set_fc[...] = tmp_fc.cpu().float().numpy()
+      d_set_att[...] = tmp_att.cpu().float().numpy()
       if i % 1000 == 0:
         print('processing %d/%d (%.2f%% done)' % (i, N, i*100.0 / N))
     file_fc.close()