So I have a few questions for implementing a custom functions. We need to do something different than gradient descend thus we try to to implement something within the forward/backward mode of pytorch, but calculating more than gradients. However, currently on a very simple example, pytorch just crashes with:

```
Traceback (most recent call last):
File "/home/alex/work/python/nn-second-order/bin/test.py", line 94, in <module>
loss.backward()
File "/usr/local/lib/python3.4/dist-packages/torch/autograd/variable.py", line 145, in backward
self._execution_engine.run_backward((self,), (gradient,), retain_variables)
RuntimeError: could not compute gradients for some functions
```

The code we are using looks like this:

```
import torch
from torch.autograd import Variable
torch.nn.Linear
class Gn_SquareLoss(torch.autograd.Function):
def forward(self, x, y):
self.save_for_backward(x, y)
diff = (x - y)
return diff.pow(2)
def backward(self, grad_output):
# N x D
x, y = self.saved_tensors
diff = (x - y) * 2
# N x D
grad_input = grad_output.clone()
# N x D
g = [grad_input * diff, grad_input * diff]
d = g[0].size()[1]
# D x D
m = [torch.eye(d, d) * 2, torch.eye(d, d) * 3]
# (N+D) x D
s1 = torch.cat((m[0], g[0]), 0)
# (N+D) x D
s2 = torch.cat((m[0], g[0]), 0)
return s1, s2
class Gn_Dot(torch.autograd.Function):
def forward(self, x, w):
self.save_for_backward(x, w)
return torch.mm(x, w)
def backward(self, grad_output):
# N x H, H x D
x, w = self.saved_tensors
# (N + D) x D
grad_input, = grad_output.clone()
d = grad_input.size()[1]
# D x D
m = grad_input[:d]
# N x D
g = grad_input[d:]
# N x H
dx = torch.mm(g, torch.transpose(w, 0, 1))
# H x D
dw = torch.mm(torch.transpose(x, 0, 1), g)
# D x H
m = torch.mm(m, torch.transpose(w, 0, 1))
# (D + N) x H
dx = torch.cat((m, dx), 0)
return dx, dw
class Gn_Tanh(torch.autograd.Function):
def forward(self, x):
self.save_for_backward(x)
return torch.tanh(x)
def backward(self, grad_output):
x, = self.saved_tensors
grad_input = grad_output.clone()
d = grad_input.size()[1]
m = grad_input[:d]
g = grad_input[d:]
dx = torch.cat((m, g * (1 - torch.tanh(x).pow(2))), dimension=0)
return dx
dtype = torch.FloatTensor
# dtype = torch.cuda.FloatTensor # Uncomment this to run on GPU
# N is batch size; D_in is input dimension;
# H is hidden dimension; D_out is output dimension.
N, D_in, H, D_out = 64, 1000, 100, 10
# Create random Tensors to hold input and outputs, and wrap them in Variables.
x = Variable(torch.randn(N, D_in).type(dtype), requires_grad=False)
y = Variable(torch.randn(N, D_out).type(dtype), requires_grad=False)
# Create random Tensors for weights, and wrap them in Variables.
w1 = Variable(torch.randn(D_in, H).type(dtype), requires_grad=True)
w2 = Variable(torch.randn(H, D_out).type(dtype), requires_grad=True)
affine = Gn_Dot()
tanh = Gn_Tanh()
square_loss = Gn_SquareLoss()
learning_rate = 1e-6
for t in range(500):
# Forward pass: compute predicted y using operations on Variables; we compute
# ReLU using our custom autograd operation.
y1 = affine(x, w1)
h1 = tanh(y1)
y2 = affine(h1, w2)
loss1 = (y - y2).pow(2).sum()
loss = square_loss(y2, y).sum()
print(t, loss.data[0], loss1.data[0])
# Manually zero the gradients before running the backward pass
w1.grad.data.zero_()
w2.grad.data.zero_()
# Use autograd to compute the backward pass.
loss.backward()
# Update weights using gradient descent
w1.data -= learning_rate * w1.grad.data
w2.data -= learning_rate * w2.grad.data
```

Note that in order to satisfy pytorchâ€™s requirement to have the number of gradients outputed same as inputs, we concatenate the extra thing we calculate (for testing purposes this is identity matrix) and then in each layer we peel them out.

Now the main issue is that this should work, however the error pytorch is giving us in a mystery why? My guess is something is happening in the C API, but I do not know what.