.grad is None - autograd through list of Variables (MultiGPU, transformer)

I am adapting harvardNLP’s transformer. The piece of code below is the loss function for Multiple GPUs. When l.backward() is called the gradients are not backpropagated through to out_column which are a list of Variables. I am rather new to autograd and pytorch in general. May I ask how do I make sure the gradients is backpropagated to out_column? Thanks a lot!

class MultiGPULossCompute:
    "A multi-gpu loss compute and train function."
    def __init__(self, generator, criterion, devices, opt=None, chunk_size=5):
        # Send out to different gpus.
        self.generator = generator
        self.criterion = nn.parallel.replicate(criterion, 
        self.opt = opt
        self.devices = devices
        self.chunk_size = chunk_size
    def __call__(self, out, targets, normalize):
        total = 0.0
        generator = nn.parallel.replicate(self.generator, 
        out_scatter = nn.parallel.scatter(out, 
        out_grad = [[] for _ in out_scatter]
        targets = nn.parallel.scatter(targets, 

        # Divide generating into chunks.
        chunk_size = self.chunk_size
        for i in range(0, out_scatter[0].size(1), chunk_size):
            # Predict distributions
            out_column = [[Variable(o[:, i:i+chunk_size].data, 
                                    requires_grad=self.opt is not None)] 
                           for o in out_scatter]
            gen = nn.parallel.parallel_apply(generator, out_column)

            # Compute loss. 
            y = [(g.contiguous().view(-1, g.size(-1)), 
                  t[:, i:i+chunk_size].contiguous().view(-1)) 
                 for g, t in zip(gen, targets)]
            loss = nn.parallel.parallel_apply(self.criterion, y)

            # Sum and normalize loss
            l = nn.parallel.gather(loss, target_device=self.devices[0])
            l = l.sum().item()/ normalize.float()
            total += l.item()

            # Backprop loss to output of transformer
            if self.opt is not None:
                l = Variable(l, requires_grad=True)
                #print(loss.grad is None)
                #print(y.grad is None)
                #print(gen.grad is None)
                #print(out_column.grad is None)
                for j, l in enumerate(loss):

        # Backprop all loss through transformer.            
        if self.opt is not None:
            out_grad = [Variable(torch.cat(og, dim=1)) for og in out_grad]
            o1 = out
            o2 = nn.parallel.gather(out_grad, 
        return total * normalize.float()