神经网络学习小记录52——Pytorch搭建孪生神经网络（Siamese network）比较图片相似性

比眉伴天荒 2023-02-27 12:06 66阅读 0赞

### 神经网络学习小记录52——Pytorch搭建孪生神经网络（Siamese network）比较图片相似性 ###

*  学习前言
 *  什么是孪生神经网络
 *  代码下载
 *  孪生神经网络的实现思路
 *   *  一、预测部分
     *   *  1、主干网络介绍
         *  2、比较网络
     *  二、训练部分
     *   *  1、数据集的格式
         *  2、Loss计算
 *  训练自己的孪生神经网络
 *   *  1、训练本文所使用的Omniglot例子
     *  2、训练自己相似性比较的模型

# 学习前言 #

也学习一下Pytorch版本的。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center]

# 什么是孪生神经网络 #

简单来说，孪生神经网络（Siamese network）就是“连体的神经网络”，神经网络的“连体”是通过共享权值来实现的，如下图所示。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 1]  
所谓权值共享就是当神经网络有两个输入的时候，这两个输入使用的神经网络的权值是共享的（**可以理解为使用了同一个神经网络**）。

很多时候，我们需要去**评判两张图片的相似性，比如比较两张人脸的相似性，我们可以很自然的想到去提取这个图片的特征**再进行比较，自然而然的，我们又可以想到**利用神经网络进行特征提取**。  
如果使用两个神经网络分别对图片进行**特征提取，提取到的特征很有可能不在一个域中，此时我们可以考虑使用一个神经网络进行特征提取再进行比较**。这个时候我们就可以理解孪生神经网络为什么要进行权值共享了。

孪生神经网络有两个输入（Input1 and Input2），利用神经网络将输入映射到新的空间，形成输入在新的空间中的表示。通过Loss的计算，评价两个输入的相似度。

# 代码下载 #

[https://github.com/bubbliiiing/Siamese-pytorch][https_github.com_bubbliiiing_Siamese-pytorch]

# 孪生神经网络的实现思路 #

## 一、预测部分 ##

### 1、主干网络介绍 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 2]  
孪生神经网络的主干特征提取网络的功能是进行特征提取，各种神经网络都可以适用，本文使用的神经网络是VGG16。  
关于VGG的介绍大家可以看我的另外一篇博客[https://blog.csdn.net/weixin\_44791964/article/details/102779878][https_blog.csdn.net_weixin_44791964_article_details_102779878]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 3]  
这是一个VGG被用到烂的图，但确实很好的反应了VGG的结构：  
**1、一张原始图片被resize到指定大小，本文使用105x105。  
2、conv1包括两次\[3,3\]卷积网络，一次2X2最大池化，输出的特征层为64通道。  
3、conv2包括两次\[3,3\]卷积网络，一次2X2最大池化，输出的特征层为128通道。  
4、conv3包括三次\[3,3\]卷积网络，一次2X2最大池化，输出的特征层为256通道。  
5、conv4包括三次\[3,3\]卷积网络，一次2X2最大池化，输出的特征层为512通道。  
6、conv5包括三次\[3,3\]卷积网络，一次2X2最大池化，输出的特征层为512通道。**

实现代码为：

import torch
    import torch.nn as nn
    from torchvision.models.utils import load_state_dict_from_url
    
    class VGG(nn.Module):
        def __init__(self, features, num_classes=1000):
            super(VGG, self).__init__()
            self.features = features
            self.avgpool = nn.AdaptiveAvgPool2d((7, 7))
            self.classifier = nn.Sequential(
                nn.Linear(512 * 7 * 7, 4096),
                nn.ReLU(True),
                nn.Dropout(),
                nn.Linear(4096, 4096),
                nn.ReLU(True),
                nn.Dropout(),
                nn.Linear(4096, num_classes),
            )
            self._initialize_weights()
    
        def forward(self, x):
            x = self.features(x)
            x = self.avgpool(x)
            x = torch.flatten(x, 1)
            x = self.classifier(x)
            return x
    
        def _initialize_weights(self):
            for m in self.modules():
                if isinstance(m, nn.Conv2d):
                    nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
                    if m.bias is not None:
                        nn.init.constant_(m.bias, 0)
                elif isinstance(m, nn.BatchNorm2d):
                    nn.init.constant_(m.weight, 1)
                    nn.init.constant_(m.bias, 0)
                elif isinstance(m, nn.Linear):
                    nn.init.normal_(m.weight, 0, 0.01)
                    nn.init.constant_(m.bias, 0)
    
    
    def make_layers(cfg, batch_norm=False):
        layers = []
        in_channels = 1
        for v in cfg:
            if v == 'M':
                layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
            else:
                conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
                if batch_norm:
                    layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)]
                else:
                    layers += [conv2d, nn.ReLU(inplace=True)]
                in_channels = v
        return nn.Sequential(*layers)
    
    
    cfgs = {
        
        'D': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M']
    }
    
    
    def VGG16(pretrained, **kwargs):
        model = VGG(make_layers(cfgs["D"], batch_norm=False), **kwargs)
        if pretrained:
            state_dict = load_state_dict_from_url("https://download.pytorch.org/models/vgg16-397923af.pth", model_dir="./model_data")
            model.load_state_dict(state_dict)
        return model

### 2、比较网络 ###

将这两个一维向量进行相减，再进行绝对值求和，相当于求取了两个特征向量插值的L1范数。也就相当于求取了两个一维向量的距离。

**然后对这个距离再进行两次全连接，第二次全连接到一个神经元上，对这个神经元的结果取sigmoid，使其值在0-1之间，代表两个输入图片的相似程度。**

实现代码如下：

import torch
    import torch.nn as nn
    from nets.vgg import VGG16
    
        
    def get_img_output_length(width, height):
        def get_output_length(input_length):
            # input_length += 6
            filter_sizes = [2, 2, 2, 2, 2]
            padding = [0, 0, 0, 0, 0]
            stride = 2
            for i in range(5):
                input_length = (input_length+2*padding[i]-filter_sizes[i]) // stride + 1
            return input_length
        return get_output_length(width)*get_output_length(height) 
        
    class Siamese(nn.Module):
        def __init__(self, input_shape, pretrained=False):
            super(Siamese, self).__init__()
            self.vgg = VGG16(pretrained)
            del self.vgg.avgpool
            del self.vgg.classifier
            
            flat_shape = 512 * get_img_output_length(input_shape[1],input_shape[0])
            self.fully_connect1 = torch.nn.Linear(flat_shape,512)
            self.fully_connect2 = torch.nn.Linear(512,1)
    
        def forward(self, x):
            x1, x2 = x
            x1 = self.vgg.features(x1)
            x2 = self.vgg.features(x2)
            b, _, _, _ = x1.size()        
            x1 = x1.view([b,-1])
            x2 = x2.view([b,-1])
            x = torch.abs(x1-x2)
            x = self.fully_connect1(x)
            x = self.fully_connect2(x)
            return x

## 二、训练部分 ##

### 1、数据集的格式 ###

本文所使用的数据集为Omniglot数据集。  
其包含来自 50不同字母（语言）的1623 个不同手写字符。每一个字符都是由 20个不同的人通过亚马逊的 Mechanical Turk 在线绘制的。

**相当于每一个字符有20张图片，然后存在1623个不同的手写字符，我们需要利用神经网络进行学习，去区分这1623个不同的手写字符，比较输入进来的字符的相似性。**

本博客中数据存放格式有三级：

- image_background
    	- Alphabet_of_the_Magi
    		- character01
    			- 0709_01.png
    			- 0709_02.png
    			- ……
    		- character02
    		- character03
    		- ……
    	- Anglo-Saxon_Futhorc
    	- ……

**最后一级的文件夹用于分辨不同的字体，同一个文件夹里面的图片属于同一文字。在不同文件夹里面存放的图片属于不同文字。**  
![在这里插入图片描述][20200714203846304.png_pic_center]  
![在这里插入图片描述][20200714203851329.png_pic_center]  
**上两个图为.\\images\_background\\Alphabet\_of\_the\_Magi\\character01里**的两幅图。它们两个属于同一个字。  
![在这里插入图片描述][20200714204458937.png_pic_center]  
**上一个图为.\\images\_background\\Alphabet\_of\_the\_Magi\\character02里**的一幅图。它和上面另两幅图不属于同一个字。

### 2、Loss计算 ###

对于孪生神经网络而言，其具有两个输入。

**当两个输入指向同一个类型的图片时，此时标签为1。**

**当两个输入指向不同类型的图片时，此时标签为0。**

**然后将网络的输出结果和真实标签进行交叉熵运算，就可以作为最终的loss了。**

本文所使用的Loss为binary\_crossentropy。

**当我们输入如下两个字体的时候，我们希望网络的输出为1。**  
![在这里插入图片描述][20200714203846304.png_pic_center]  
![在这里插入图片描述][20200714203851329.png_pic_center]  
我们会将预测结果和1求交叉熵。

**当我们输入如下两个字体的时候，我们希望网络的输出为0。**  
![在这里插入图片描述][20200714203846304.png_pic_center]  
![在这里插入图片描述][20200714204458937.png_pic_center]  
我们会将预测结果和0求交叉熵。

# 训练自己的孪生神经网络 #

## 1、训练本文所使用的Omniglot例子 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 4]  
下载数据集，放在根目录下的dataset文件夹下。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 5]  
运行train.py开始训练。  
![在这里插入图片描述][20200714212953877.png]

## 2、训练自己相似性比较的模型 ##

如果大家想要训练自己的数据集，可以将数据集按照如下格式进行摆放。  
![在这里插入图片描述][20200717132416288.png_pic_center]  
每一个chapter里面放同类型的图片。  
之后将train.py当中的train\_own\_data设置成True，即可开始训练。  
![在这里插入图片描述][20200717132625692.png_pic_center]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center]: /images/20230209/fa58739e805b4a1ab34c62a9b1da8894.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20230209/3d72c3072ec74cec896131bf1494a808.png
[https_github.com_bubbliiiing_Siamese-pytorch]: https://github.com/bubbliiiing/Siamese-pytorch
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20230209/169fd720b9fa4de7b65ff145e070bbf2.png
[https_blog.csdn.net_weixin_44791964_article_details_102779878]: https://blog.csdn.net/weixin_44791964/article/details/102779878
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20230209/bd63b02c5a23403fbba56c2e0497430e.png
[20200714203846304.png_pic_center]: https://img-blog.csdnimg.cn/20200714203846304.png#pic_center
[20200714203851329.png_pic_center]: https://img-blog.csdnimg.cn/20200714203851329.png#pic_center
[20200714204458937.png_pic_center]: https://img-blog.csdnimg.cn/20200714204458937.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 4]: https://img-blog.csdnimg.cn/20200717132249314.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 5]: https://img-blog.csdnimg.cn/20200714212649786.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA==,size_16,color_FFFFFF,t_70#pic_center
[20200714212953877.png]: https://img-blog.csdnimg.cn/20200714212953877.png
[20200717132416288.png_pic_center]: https://img-blog.csdnimg.cn/20200717132416288.png#pic_center
[20200717132625692.png_pic_center]: https://img-blog.csdnimg.cn/20200717132625692.png#pic_center