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

最新推荐文章于 2024-07-28 23:38:39 发布

hudongloop

最新推荐文章于 2024-07-28 23:38:39 发布

阅读量2.4w

点赞数 14

分类专栏： PyTorch 文章标签：损失函数 PyTorch

本文链接：https://blog.csdn.net/u011276025/article/details/71285222

版权

PyTorch 专栏收录该内容

8 篇文章 30 订阅

订阅专栏

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

PyTorch的学习和使用（二）

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

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

数据预处理

Siamese的网络结构如下：

siamese

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

我们还是使用手写数据集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()**实现如下：

Siamese

上述代码中，bottom[0],bottom[1]存的2张图片的特征，bottom[2]，bottom[3]存的2张图片的标签，然后根据其是否相同进行如下计算：
$\begin{cases} ||a_i - b_i||_2^2, & \text{if a == b} \\[2ex] max \{ 0, m - ||a_i - b_i||_2^2\}^2, & \text{if a != b} \end{cases}$

$\frac{1}{2N} \cdot loss$
在论文Learning a Similarity Metric Discriminatively, with Application to Face Verification中，其定义的损失函数为：
Siamese1
要求满足：
Siamese2

则当 $E_W(X_1,X_2^{'})->0$ 时, $E_W(X_1,X_2)->m$

其**backward()**如下：
Siamese3

$\frac{1}{2}loss$ 的导数为
$\frac{\partial loss}{\partial a}= \begin{cases} \sum(a-b), & \text{if a == b} \\[2ex] (m - ||a_i - b_i||_2^2)\cdot \sum(a-b), & \text{if a != b} \end{cases}$
根据导数计算，实现bankward()。当前导数乘后一层梯度为当前梯度。

CosineEmbeddingLoss实现

然后，在PyTorch中实现。在PyTorch中有实现CosineEmbeddingLoss损失函数，其定义为：
$\begin{cases} 1 - cos(x1, x2), & \text{if y == 1} \\[2ex] max \{ 0, cos(x1, x2) \}, & \text{if y == -1} \end{cases}$
该函数和我们需要实现的Contrastive_loss损失函数类似，我们先分析CosineEmbeddingLoss函数的实现，任何构造自己的Contrastive_loss损失函数。

就如同PyTorch文档中所讲的，如果实现扩展 torch.autograd，需要实现3个方法：

init (optional), 用于传递一些参数，比如margin, 和size_average.。
forward(), 前向传播，就是进行计算。
backward()，反向传播，就是求导计算梯度。

其**forward()**实现如下：

实现CosineEmbeddingLoss函数主要就是完成cos(a, b)的计算。 $\frac{a*b}{|a| |b|}$ .
代码主要可以分为4部分，如下图所示:

第一部分计算 $a$ 向量和 $b$ 向量的乘积 $a * b$
第二部分计算 $a$ 向量和 $b$ 向量模平方分之1， $\frac{1}{|a|^2}$ 和 $\frac{1}{|b|^2}$
第三部分计算 $a$ 向量乘 $b$ 向量模分之1， $\frac{1}{|a| |b|}$
第四部分计算 $\frac{a*b}{|a| |b|}$

其**backward()**如下：

**backward()**就是实现CosineEmbeddingLoss的导数，主要计算 $\frac{a*b}{|a| |b|}$ 的导数。根据 $(\frac{u}{v})'=\frac{u'v - uv'}{v^2}$ 得：
$KaTeX parse error: No such environment: align at position 8: \begin{̲a̲l̲i̲g̲n̲}̲ cos(a, b)' & =…$
由于：
$(a*b)'=[(a_1, a_2, ..., a_n)*b]'=b$
$|a|'=[(a_1^2, a_2^2, ..., a_n^2)^{1/2}]'=\frac{1}{2} \frac{2(a_1, a_2, ..., a_n)}{(a_1^2, a_2^2, ..., a_n^2)^{1/2}} = \frac{a}{|a|}$

因此，可得：
$KaTeX parse error: No such environment: align at position 8: \begin{̲a̲l̲i̲g̲n̲}̲ \frac{1}{|b|} …$

在上图代码的说明中：

1表示： $\frac{a*b}{|a|^2}$
2表示： $\frac{a*b}{|a|^2} \cdot a - b$
3表示： $\frac{\frac{a*b}{|a|^2} \cdot a - b}{|a| |b|}$
最后，当前导数乘后一层梯度为当前梯度。

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

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

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++实现要方便的多（至少不用指针指来指去），值得注意的有以下几点：

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_©即可。
使用索引时不能进行in-place。 比如有个索引idx，Tensor变量a，当使用a[idx].add_()时不会改变a的值。
少使用=进行赋值，多使用in-place和out=。 因为=进行赋值为浅拷贝，赋值的是地址指针，当其中一个改变时，会影响另一个值。如下所示：