Hi, I read PyTorch with Example and I tried to implement network with learned parameters and custom loss function. Following is abstract of what I did:

- Loaded learned model of ‘model.pth’ which was converted from ‘.t7’ by using convert_torch_to_pytorch
- Defined custom loss function of
`triplet_loss()`

which is unsure of working properly

Below is the code:

```
# define custom loss function
from torch import exp
from torch.autograd import Variable
class LambdaBase(nn.Sequential):
def __init__(self, fn, *args):
super(LambdaBase, self).__init__(*args)
self.lambda_func = fn
def forward_prepare(self, input):
output = []
for module in self._modules.values():
output.append(module(input))
return output if output else input
class Lambda(LambdaBase):
def forward(self, input):
return self.lambda_func(self.forward_prepare(input))
model = nn.Sequential( # Sequential,
nn.Conv2d(3,64,(3, 3),(1, 1),(1, 1)),
nn.ReLU(),
nn.Conv2d(64,64,(3, 3),(1, 1),(1, 1)),
nn.ReLU(),
nn.Dropout(0.25),
nn.MaxPool2d((4, 4),(4, 4)),
nn.BatchNorm2d(64,0.001,0.9,True),
nn.Conv2d(64,128,(3, 3),(1, 1),(1, 1)),
nn.ReLU(),
nn.Conv2d(128,128,(3, 3),(1, 1),(1, 1)),
nn.ReLU(),
nn.Dropout(0.25),
nn.MaxPool2d((4, 4),(4, 4)),
nn.BatchNorm2d(128,0.001,0.9,True),
nn.Conv2d(128,256,(3, 3),(1, 1),(1, 1)),
nn.ReLU(),
nn.Conv2d(256,256,(3, 3),(1, 1),(1, 1)),
nn.ReLU(),
nn.Dropout(0.25),
nn.MaxPool2d((4, 4),(4, 4)),
nn.BatchNorm2d(256,0.001,0.9,True),
nn.Conv2d(256,128,(1, 1)),
nn.ReLU(),
Lambda(lambda x: x.view(x.size(0),-1)), # Reshape,
nn.Sequential(Lambda(lambda x: x.view(1,-1) if 1==len(x.size()) else x ),nn.Linear(3072,128)), # Linear,
)
model.load_state_dict(torch.load('model.pth'))
def triplet_loss(vec_ref, vec_pos, vec_neg):
dist_pos = torch.norm(vec_ref - vec_pos, 2)
dist_neg = torch.norm(vec_ref - vec_neg, 2)
reg_dist_pos = exp(dist_pos)/(exp(dist_pos) + exp(dist_neg))
reg_dist_neg = exp(dist_neg)/(exp(dist_pos) + exp(dist_neg))
loss = reg_dist_pos
return loss
learning_rate = 1e-4
triplet_samples = 100
for t in range(triplet_samples):
# extract feature of t th image triplet
# img_***[t] is tensor of image
y_ref = model(img_ref[t])
y_pos = model(img_pos[t])
y_neg = model(img_var[t])
loss = triplet_loss(y_ref, y_pos, y_neg)
print(t, loss.data[0])
model.zero_grad()
loss.backward()
for param in model.parameters():
param.data -= learning_rate * param.grad.data
```

I tried this code on one image triplet and worked and computed loss. But I’m not sure whether the `loss.backward()`

properly works. Could you explain it is properly implemented or not?

Thank you.