PyTorch(二)——搭建和自定义网络

目录连接
(1) 数据处理
(2) 搭建和自定义网络
(3) 使用训练好的模型测试自己图片
(4) 视频数据的处理
(5) PyTorch源码修改之增加ConvLSTM层
(6) 梯度反向传递(BackPropogate)的理解
(总) PyTorch遇到令人迷人的BUG

PyTorch的学习和使用（二）

最近刚好在看一篇与Siamese network有关的论文，在PyTorch中没有example，caffe中有，刚好使用PyTorch实现。（PS：图片单独打开更清晰）
主要步骤为：

• 数据预处理
• 模型搭建
• 模型训练

数据预处理

Siamese的网络结构如下：

通过输入两张图片X1和X2，经过权重共享的CNN，各自得到一个输出特征向量Gw(X1)和Gw(X2)，然后使用特征向量的距离度量两张图片的相似度。

我们还是使用手写数据集MINIST作为测试（主要有mnist的列子可以参考），网络输入的图片为成对的，因此在构造训练的batch时需要定义2张图片，其标签为两张图片是否为同一个数字。根据上篇文章讲的，重新定义transforms.Compose()和torchvision.datasets.SIAMESE()。

由于对数据的读取和处理都没有改变，因此不用修改Compose()。torchvision.datasets.SIAMESE()则把相邻的图片捆绑在一起，作为一对输入图片，如果相同的数字，则标签为1，不同则为0。
如下所示：

如图所示每个batch中有2个图片，但是在训练中我们希望每个相邻的batch为一对图片，因此做如下处理：images.view(batch*2, 1, 28, 28)得到如下结果：

网络的搭建

Siamese的网络定义与LeNet模型基本一致，唯一不同的是把生成10个数字类别概率的顶层替换为生成二维向量的特征层，最后损失函数换为对比损失函数（Contrastive_loss）(很忧伤，该损失函数在PyTorch中暂时没有实现)。因此需要自己实现Contrastive_loss层。

Contrastive_loss函数定义

首先，理解caffe中Siamese网络如和实现的。contrastive_loss_layer定义如下：

其forward()实现如下：

上述代码中，bottom[0],bottom[1]存的2张图片的特征，bottom[2]，bottom[3]存的2张图片的标签，然后根据其是否相同进行如下计算：

loss=⎧⎩⎨||ai−bi||22,max{0,m−||ai−bi||22}2,if a == bif a != b

Loss=12N⋅loss

在论文Learning a Similarity Metric Discriminatively, with Application to Face Verification中，其定义的损失函数为：

要求满足：

则当EW(X1,X′2)−>0时, EW(X1,X2)−>m

其backward()如下：

12loss的导数为

∂loss∂a=⎧⎩⎨∑(a−b),(m−||ai−bi||22)⋅∑(a−b),if a == bif a != b

根据导数计算，实现bankward()。当前导数乘后一层梯度为当前梯度。

CosineEmbeddingLoss实现

然后，在PyTorch中实现。在PyTorch中有实现CosineEmbeddingLoss损失函数，其定义为：

loss(x,y)=⎧⎩⎨1−cos(x1,x2),max{0,cos(x1,x2)},if y == 1if y == -1

该函数和我们需要实现的Contrastive_loss损失函数类似，我们先分析CosineEmbeddingLoss函数的实现，任何构造自己的Contrastive_loss损失函数。

就如同PyTorch文档中所讲的，如果实现扩展 torch.autograd，需要实现3个方法：
- init (optional), 用于传递一些参数，比如margin, 和size_average.。
- forward(), 前向传播，就是进行计算。
- backward()， 反向传播，就是求导计算梯度。

其forward()实现如下：

实现CosineEmbeddingLoss函数主要就是完成cos(a, b)的计算。cos(a,b)=a∗b|a||b|.
代码主要可以分为4部分，如下图所示:
- 第一部分计算a向量和b向量的乘积a∗b
- 第二部分计算a向量和b向量模平方分之1，1|a|2和1|b|2
- 第三部分计算a向量乘b向量模分之1，1|a||b|
- 第四部分计算cos(a,b)=a∗b|a||b|

其backward()如下：

backward()就是实现CosineEmbeddingLoss的导数，主要计算cos(a,b)=a∗b|a||b|的导数。根据(uv)′=u′v−uv′v2得：

cos(a,b)′=(a∗b|a||b|)′=1|b|⋅(a∗b)′|a|−(a∗b)|a|′|a|2

由于：

(a∗b)′=[(a1,a2,...,an)∗b]′=b

|a|′=[(a21,a22,...,a2n)1/2]′=122(a1,a2,...,an)(a21,a22,...,a2n)1/2=a|a|

因此，可得：

1|b|⋅(a∗b)′|a|−(a∗b)|a|′|a|2=1|b|⋅b|a|−(a∗b)a|a||a|2=a∗b|a|2⋅a−b|a||b|

在上图代码的说明中：
- 1表示：a∗b|a|2
- 2表示：a∗b|a|2⋅a−b
- 3表示：a∗b|a|2⋅a−b|a||b|
最后，当前导数乘后一层梯度为当前梯度。

Contrastive_loss损失函数实现

ps：虽然看了CosineEmbeddingLoss的实现，但是对PyTorch的矩阵计算函数还是不太熟悉，前前后后花了不少时间。

根据上面的公式，Contrastive_loss的代码实现如下：(输入为一对图片input1, input2和标签y，y==1表示同一物体，y==0表示不同物体)

class ContrastiveLoss(Function):    def __init__(self, margin=1, size_average=True):        super(ContrastiveLoss, self).__init__()        self.margin = margin        self.size_average = size_average    def forward(self, input1, input2, y):        assert input1.size() == input2.size(), "Input sizes must be equal."        self.l22 = input1.new() #l22 = ||a - b||^2        self._outputs = input1.new()        _idx = input1.new().byte()        epsilon = 1e-12 #avoid div 0        #l22 = ||a - b||^2        _diff = torch.abs(input1 - input2)        self.l22 = torch.pow(_diff + epsilon, 2).sum(dim=1)        #_output = l22        self._outputs.resize_as_(self.l22).copy_(self.l22)        self._outputs = self._outputs.select(1, 0) #_output = first column and it one column vector        torch.eq(y, 0, out=_idx) #y==0        self._outputs[_idx] = self._outputs[_idx].mul_(-1).add_(self.margin).clamp_(min=0) #max{0, m-||a-b||}^2        self._outputs[_idx] = self._outputs[_idx].pow_(2)        #_output = 1/2 * _output        self._outputs.mul_(1.0 / 2.0)        output = self._outputs.sum() #sum        if self.size_average:            output = output / y.size(0)  #mean        self.save_for_backward(input1, input2, y)        return input1.new((output,))    def backward(self, grad_output):        v1, v2, y = self.saved_tensors        buffer = v1.new()        _idx = v1.new().byte()        gw1 = grad_output.new()        gw2 = grad_output.new()        gw1.resize_as_(v1).copy_(v2) #gw1 = b        gw2.resize_as_(v2).copy_(v1) #gw2 = a        gw1.mul_(-1).add_(v1) #a' = sum(a - b)        gw2.mul_(-1).add_(v2) #b' = sum(b- a)        torch.le(self._outputs, 0, out=_idx) #find _output < 0 because loss>0        _idx = _idx.view(-1, 1).expand(gw1.size())        gw1[_idx] = 0        gw2[_idx] = 0        #y==0        torch.eq(y, 0, out=_idx)         _idx = _idx.view(-1, 1).expand(gw2.size())        torch.add(self.l22, -self.margin, out=buffer)        buffer = buffer.expand(gw1.size())        gw1[_idx] = gw1[_idx].mul(buffer[_idx])        gw2[_idx] = gw2[_idx].mul(buffer[_idx]).mul_(-1)        if self.size_average:            gw1.div_(y.size(0))            gw2.div_(y.size(0))        grad_output_val = grad_output[0] #current = lastgrad*dervative        if grad_output_val != 1:            gw1.mul_(grad_output_val)            gw2.mul_(grad_output_val)        return gw1, gw2, None

使用梯度检验：

input = (Variable(torch.randn(20, 2).double(), requires_grad = True),         Variable(torch.randn(20, 2).double(), requires_grad = True),)  test = gradcheck(ContrastiveLoss(), input, eps=1e-6, atol=1e-4)print test

返回的值为True,说明求导的backward没有问题。(需要注意的是：我们的loss函数需要3个输入，input1, input2, target. 但是在增加target时会报Kernel died, restarting错误，以为是loss代码写错了，使用自带的CosineEmbeddingLoss进行测试也是同样的结果，最后去除target得以解决。）（PS：2017.2.15, 官方以修复此bug）
通过以上代码，可以发现PyTorch的实现要比caffe使用C++实现要方便的多（至少不用指针指来指去），值得注意的有以下几点：

1. in-palce 和out-place. 比如有Tensor变量a和b，torch.add() 和torch.add_(), 分别为in-palce 和out-place版本。a.add(b) 输出 a+b，a和b的值不改变，a.add_(b) 输出a+b 并且把结果给b。这样做在进行连续计算时有好处，比如计算a*b+c, 只需要a.mul_(b).add_(c)即可。
   

2. 使用索引时不能进行in-place。 比如有个索引idx，Tensor变量a，当使用a[idx].add_()时不会改变a的值。
   

3. 少使用=进行赋值，多使用in-place和out=。 因为=进行赋值为浅拷贝，赋值的是地址指针，当其中一个改变时，会影响另一个值。如下所示：
   

Contrastive_loss损失层的增加

Contrastive_loss的算法已经实现，需要增加到PyTorch中。PyTorch为动态的实现，因此在改变源码后不需要重新编译。

增加一个自定义的层需要完成以下几步：
1. 找到PyTorch的包路径。一般在自己python环境路径下的torch下。
2. 在nn._functions.loss.py中增加上面的Contrastive_loss实现代码。

3. 在nn.functional.py 中增加Contrastive_loss的包装。（可选）

4. 在nn.modules.loss.py中增加Contrastive_loss扩展。

然后在nn.modules.init.py中进行定义，以便可以进行调用。

最后在nn.backends.thnn.py中进行backend访问定义。

Siamese网络训练结果

至此，数据的处理和网络的搭建都已近完成了。其训练结果如下：