def calc_gradient_penalty(netD, real_data, fake_data):
    alpha = torch.rand(BATCH_SIZE, 1)
    alpha = alpha.expand(real_data.size())
    alpha = alpha.cuda() if use_cuda else alpha

    interpolates = alpha * real_data + ((1 - alpha) * fake_data)
    if use_cuda:
        interpolates = interpolates.cuda()
    interpolates = autograd.Variable(interpolates, requires_grad=True)

    disc_interpolates = netD(interpolates)

    gradients = autograd.grad(outputs=disc_interpolates, inputs=interpolates,
                              grad_outputs=torch.ones(disc_interpolates.size()).cuda() if use_cuda else torch.ones(disc_interpolates.size()),
                              create_graph=True, only_inputs=True, retain_graph=True)[0]

    gradient_penalty = ((gradients.norm(2, dim=1) - 1) ** 2).mean() * LAMBDA
    return gradient_penalty

use_cuda = False
BATCH_SIZE=256
LAMBDA = 0.1
DIM = 256
noise = torch.neg(torch.randn(BATCH_SIZE, 2))
if use_cuda:
    noise = noise.cuda()
noisev = autograd.Variable(noise)

noise1 = torch.randn(BATCH_SIZE, 2)
if use_cuda:
    noise1 = noise1.cuda()
noise1v = autograd.Variable(noise1)

netD = nn.Sequential(
            nn.Linear(2, DIM),
            nn.ReLU(True),
            nn.Linear(DIM, DIM),
            nn.ReLU(True),
            nn.Linear(DIM, DIM),
            nn.ReLU(True),
            nn.Linear(DIM, 1),
        )
netD.zero_grad()
print netD
gp = calc_gradient_penalty(netD, noisev.data, noise1v.data)
gp.backward()
for p in netD.parameters():
    print p.grad

NotImplementedErrorTraceback (most recent call last)
<ipython-input-2-a841c9970f31> in <module>()
     44 print netD
     45 gp = calc_gradient_penalty(netD, noisev.data, noise1v.data)
---> 46 gp.backward()
     47 for p in netD.parameters():
     48     print p.grad

/home/users/gang.cao/env/lib/python2.7/site-packages/torch/autograd/variable.pyc in backward(self, gradient, retain_variables)
    150                 raise TypeError("gradient has to be a Tensor, Variable or None")
    151             gradient = Variable(gradient, volatile=True)
--> 152         self._execution_engine.run_backward((self,), (gradient,), retain_variables)
    153 
    154     def register_hook(self, hook):

/home/users/gang.cao/env/lib/python2.7/site-packages/torch/autograd/function.pyc in backward(*grad_outputs)
    170         be the gradient w.r.t. the corresponding input.
    171         """
--> 172         raise NotImplementedError
    173 
    174 

NotImplementedError: 

TypeError: torch.addmm received an invalid combination of arguments - got (int, torch.ByteTensor, int, torch.ByteTensor, torch.FloatTensor, out=torch.ByteTensor), but expected one of:
 * (torch.ByteTensor source, torch.ByteTensor mat1, torch.ByteTensor mat2, *, torch.ByteTensor out)
 * (torch.ByteTensor source, torch.SparseByteTensor mat1, torch.ByteTensor mat2, *, torch.ByteTensor out)
 * (int beta, torch.ByteTensor source, torch.ByteTensor mat1, torch.ByteTensor mat2, *, torch.ByteTensor out)
 * (torch.ByteTensor source, int alpha, torch.ByteTensor mat1, torch.ByteTensor mat2, *, torch.ByteTensor out)
 * (int beta, torch.ByteTensor source, torch.SparseByteTensor mat1, torch.ByteTensor mat2, *, torch.ByteTensor out)
 * (torch.ByteTensor source, int alpha, torch.SparseByteTensor mat1, torch.ByteTensor mat2, *, torch.ByteTensor out)
 * (int beta, torch.ByteTensor source, int alpha, torch.ByteTensor mat1, torch.ByteTensor mat2, *, torch.ByteTensor out)
      didn't match because some of the arguments have invalid types: (int, torch.ByteTensor, int, torch.ByteTensor, !torch.FloatTensor!, out=torch.ByteTensor)
 * (int beta, torch.ByteTensor source, int alpha, torch.SparseByteTensor mat1, torch.ByteTensor mat2, *, torch.ByteTensor out)
      didn't match because some of the arguments have invalid types: (int, torch.ByteTensor, int, !torch.ByteTensor!, !torch.FloatTensor!, out=torch.ByteTensor)

torch/nn/_functions/thnn/activation.py

         else:
+            mask = input > ctx.threshold
+            grad_input = mask.type_as(grad_output) * grad_output
-            grad_input = grad_output.masked_fill(input > ctx.threshold, 0)
         return grad_input, None, None, None