网络结构核心单元

野性酷女 2023-01-10 10:25 138阅读 0赞

### **1、resnet残差网络** ###

1.  较深的网络比较浅的网络性能更差。 一个创新的想法：如果什么也没学到，那就比以前更糟：因此提出了identity map（也称为shortcut连接）。 H（x）= x + F（x），F（x）= H（x）-x，称为残差。
2.  ResNet的深度各不相同，从18层到34、50、101到非常深的152层。
3.  不同的快捷方式，如果不更改尺寸，则可以使用身份映射。 但是在实践中，尺寸更改因此会产生“瓶颈”。 （这在基线后记中很流行，因为它可以保存参数。）

残差单元：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NlbmJpbnl1_size_16_color_FFFFFF_t_70_pic_center][]

跨层连接：要求输入x：feature map的shape与输出F(x)：feature map 的shape一样。

可能存在的情况：

①输入x与输出F(x) 的shape一样直接相加

②输入x输出F(x) 的feature map数量及feature map尺寸不一样

如：输入x：\[1, 64, 224, 224\]输出F(x) ：\[1, 128, 112, 112\]

需要对输入x通过卷积层各参数调整，确保与F(x)一致

相邻的x 与F(x)通道不一致，fp也相差一倍

import torch.nn as nn
    import torch
    
    
    #残差单元
    class Block(nn.Module):
        def __init__(self,inch,outch,stride):
            super(Block, self).__init__()
    
            self.con1=nn.Conv2d(inch,outch,3,stride,1)
            self.con2=nn.Conv2d(outch,outch,3,1,1)
            self.relu=nn.ReLU()
            self.bn=nn.BatchNorm2d(outch)
    
            if inch!=outch:
                self.downsample=nn.Conv2d(inch,outch,1,stride)#输入与输出通道不一致，调整通道并通过步长调整特征图
            else:
                self.downsample=None
    
        def forward(self,x):
            pre=x
            out=self.con1(x)
            out=self.relu(out)
            out=self.bn(out)
            out=self.con2(out)
            out = self.bn(out)
    
            if self.downsample is not None:#
                pre=self.downsample(x)
    
            out+=pre#跨层连接相加：x+F(x)
            out = self.relu(out)
            return out
    
    
    class mynet(nn.Module):
        def __init__(self,Block):
            super(mynet, self).__init__()
    
            self.layer1=nn.Sequential(nn.Conv2d(3,64,3,1,1),
                                      nn.BatchNorm2d(64),
                                      nn.MaxPool2d(2))#64,224
    
            self.layer2=self.layer(Block,64,64,3,1)
    
            self.layer3 = self.layer(Block, 64, 128,4, 2)#连续有4个残差单元除了第一个要增加通道，后面保持与上个一样
            self.layer4 = self.layer(Block, 128, 256, 6,2)
            self.layer5 = self.layer(Block, 256, 512, 3, 2)
    
        def layer(self,Block,inch,outch,blocknum,stride):
            layers=[]
            layers.append(Block(inch,outch,stride))#主要负责调整每个block的特征图及通道
            for i in range(blocknum-1):
                layers.append(Block(outch,outch,1))#普通的卷积操作并且通道一致
    
            return nn.Sequential(*layers)#以列表形式放在序列化中
    
    
    
        def forward(self,x):
            x1=self.layer1(x)
            print(x1.shape)
            x2 = self.layer2(x1)
            print(x2.shape)
            x3 = self.layer3(x2)
            print(x3.shape)
            x4 = self.layer4(x3)
            print(x4.shape)
            x5 = self.layer5(x4)
            print(x5.shape)
            return x1,x2
    
    
    
    
    x=torch.randn(1,3,448,448)
    model=mynet(Block)
    y1,y2=model(x)
    # print(y1.shape,y2.shape)

### **2、Googlenet中inception单元** ###

1.  除了增加网络深度之外（对于googlenet v1为22层），还会增加网络的宽度
2.  引入较小的内核，1 \* 1卷积，减小尺寸并保存参数。 参数：AlexNet ~ 12 GoogLeNet, VGG ~ 3 AlexNet
3.  初始模块很容易添加或删除，它是模仿人的大脑以建立稀疏连接。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NlbmJpbnl1_size_16_color_FFFFFF_t_70_pic_center 1][]

import torch
    import torch.nn as nn
    
    
    
    class inception(nn.Module):
        def __init__(self,inch,outch):
            super(inception, self).__init__()
            self.con1=nn.Conv2d(inch,outch,1,1)
            self.con2=nn.Conv2d(inch,outch,3,1,1)
            self.con3=nn.Conv2d(inch,outch,5,1,2)
            self.maxpool=nn.MaxPool2d(3,1,1)
    
        def forward(self,x):
            out1=self.con1(x)
            out2=self.con2(x)
            out3=self.con3(x)
            out4=self.maxpool(x)
            out=torch.cat((out1,out2,out3,out4),dim=1)#特征融合
            return out
    
    
    
    
    
    
    class mynet(nn.Module):
        def __init__(self,inception):
            super(mynet, self).__init__()
            self.layer1=nn.Sequential(
                nn.Conv2d(3, 64, 3, 1, 1),
                nn.MaxPool2d(2)
            )
    
            self.layer2=inception(64,64)
        def forward(self,x):
            x=self.layer1(x)
            x=self.layer2(x)
    
            return x
    
    
    
    x=torch.randn(1,3,448,448)
    model=mynet(inception)
    y=model(x)
    print(y.shape)

### 3、Yolov3 ###

### ①无yolo层的darknet53 主干网络backbone： ###

![e94ecc6bbec06fb754a40f31ca05072a.png][]

## ##

[图片来源于][Link 1]

### ②含有YOLO层的网络 ###

![f8e203da22a08b4c1b9274f669c7749a.png][]

将输出调整为：（batch,3\*(x,y,w,h,conf,cls1...cls20),fp,fp）

import torch
    import torch.nn as nn
    import torch.nn.functional as F
    class ResidualBlock(nn.Module):
        def __init__(self,inch,outch):
            super(ResidualBlock, self).__init__()
    
            self.conv1=nn.Sequential(nn.Conv2d(inch,outch,1,1),
                                     nn.BatchNorm2d(outch),
                                     nn.LeakyReLU())
            self.conv2=nn.Sequential(nn.Conv2d(outch,inch,3,1,1),
                                    nn.BatchNorm2d(inch),
                                    nn.LeakyReLU())
    
        def forward(self, x):
            identity=x
            out=self.conv1(x)
            out=self.conv2(out)
    
            out+=identity
            return out
    
    class UpsampleLayer(nn.Module):
        def __init__(self):
            super(UpsampleLayer, self).__init__()
        def forward(self, x):
            return F.interpolate(x, scale_factor=2, mode='nearest')
    
    class ConvolutionalSetLayer(nn.Module):
        def __init__(self,inch,outch):
            super(ConvolutionalSetLayer, self).__init__()
            self.conv=nn.Sequential(
                nn.Conv2d(inch, outch, 1, 1),
                nn.Conv2d(outch, inch, 3, 1, 1),
                nn.Conv2d(inch, outch, 1, 1),
                nn.Conv2d(outch, inch, 3, 1, 1),
                nn.Conv2d(inch, outch, 1, 1)
            )
        def forward(self,x):
            return self.conv(x)
    
    
    
    class Darknet53(nn.Module):
        def __init__(self,ResidualBlock):
            super(Darknet53, self).__init__()
            self.firstblock=nn.Sequential(nn.Conv2d(3,32,3,1,1),
                                          nn.BatchNorm2d(32),
                                          nn.LeakyReLU()
                                          )
            self.conv1 = nn.Conv2d(32, 64, 3, 2, 1)
            self.resblock1=self.block(ResidualBlock,32,64,1)
            self.conv2 = nn.Conv2d(64, 128, 3, 2, 1)
            self.resblock2 = self.block(ResidualBlock, 64, 128, 2)
            self.conv3 = nn.Conv2d(128, 256, 3, 2, 1)
            self.resblock3 = self.block(ResidualBlock, 128, 256, 8)
            self.conv4 = nn.Conv2d(256, 512, 3, 2, 1)
            self.resblock4 = self.block(ResidualBlock, 256, 512, 8)
            self.conv5 = nn.Conv2d(512, 1024, 3, 2, 1)
            self.resblock5 = self.block(ResidualBlock, 512, 1024, 4)
    
            self.conset13=nn.Sequential(ConvolutionalSetLayer(1024,512))
            self.conset26 = nn.Sequential(ConvolutionalSetLayer(768, 256))
            self.conset52 = nn.Sequential(ConvolutionalSetLayer(384, 128))
    
            self.yololy1=nn.Sequential(
                nn.Conv2d(512, 1024, 3, 1, 1),
                nn.BatchNorm2d(1024),
                nn.LeakyReLU(),
                nn.Conv2d(1024,75,1,1)
    
            )
    
            self.yololy2 = nn.Sequential(
                nn.Conv2d(256, 512, 3, 1, 1),
                nn.BatchNorm2d(512),
                nn.LeakyReLU(),
                nn.Conv2d(512, 75, 1, 1)
    
            )
    
            self.yololy3 = nn.Sequential(
                nn.Conv2d(128, 256, 3, 1, 1),
                nn.BatchNorm2d(256),
                nn.LeakyReLU(),
                nn.Conv2d(256, 75, 1, 1)
    
            )
            self.up1=nn.Sequential(
                nn.Conv2d(512, 256, 1, 1),
                UpsampleLayer()
            )
            self.up2 = nn.Sequential(
                nn.Conv2d(256, 128,1, 1),
                UpsampleLayer()
            )
    
    
    
    
        def block(self,ResidualBlock,inch, outch, numblock):
    
            layers=[]
            # layers.append(nn.Conv2d(inch,outch,3,2,1))
            for i in range(numblock - 1):
                layers.append(ResidualBlock(outch,inch))
            return nn.Sequential(*layers)
    
    
    
    
        def forward(self,x):
            out=self.firstblock(x)
            out=self.conv1(out)
            out=self.resblock1(out)
            out = self.conv2(out)
            out = self.resblock2(out)
            out = self.conv3(out)
            fp_52 = self.resblock3(out)
            out = self.conv4(fp_52)
            fp_26 = self.resblock4(out)
            out = self.conv5(fp_26)
            fp_13 = self.resblock5(out)
    
            convset13=self.conset13(fp_13)
            yoloout1=self.yololy1(convset13)
    
            up1=self.up1(convset13)
            route1=torch.cat((up1,fp_26),1)
            convset26=self.conset26(route1)
            yoloout2=self.yololy2(convset26)
    
            up2=self.up2(convset26)
            route2=torch.cat((up2,fp_52),1)
            convset52=self.conset52(route2)
            yoloout3=self.yololy3(convset52)
    
    
    
    
            return yoloout1,yoloout2,yoloout3
    
    
    inputs=torch.randn(1,3,416,416)
    model=Darknet53(ResidualBlock)
    print(model)
    sc1,sc2,sc3=model(inputs)
    print(sc1.shape,sc2.shape,sc3.shape)

### 4、Yolov4 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU2MDQwMg_size_16_color_FFFFFF_t_70_pic_center][]

YOLOv4模型由以下部分组成：

*  **CSPDarknet53([参考][Link 2])**作为骨干网络BackBone；
 *  **SPP**作为Neck的附加模块，**PANet**作为Neck的特征融合模块；
 *  **YOLOv3**作为Head。

### ①、[CSPNet][] ###

Cross Stage Partial（CSP）可以增强CNN的学习能力，能够在轻量化的同时保持准确性、降低计算瓶颈、降低内存成本。

[神经网络中不同类型的卷积层][Link 3]

作者认为推理计算过高的问题是由于网络优化中的梯度信息重复导致的。CSPNet通过将梯度的变化从头到尾地集成到特征图中，在减少了计算量的同时可以保证准确率。CSPNet是一种处理的思想，可以和ResNet、ResNeXt和DenseNet结合。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3MjY0Mzk3_size_16_color_FFFFFF_t_70][]

将上一层分为两部分，Part1不进行操作直接concate，Part2进行卷积操作.

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3MjY0Mzk3_size_16_color_FFFFFF_t_70 1][]

import torch
    import torch.nn as nn
    import torch.nn.functional as F
    
    class Mish(nn.Module):
        def __init__(self):
            super(Mish, self).__init__()
    
        def forward(self,x):
            return x*torch.tanh(F.softplus(x))
    
    class BasicConv(nn.Module):
        def __init__(self,inch,outch,ksize,stride=1):
            super(BasicConv, self).__init__()
            self.layer=nn.Sequential(
                nn.Conv2d(inch, outch, ksize,stride,ksize//2),
                nn.BatchNorm2d(outch),
                Mish()
            )
        def forward(self,x):
            return self.layer(x)
    
    
    class Resblock(nn.Module):
        def __init__(self,inch,outch):
            super(Resblock, self).__init__()
    
            self.block=nn.Sequential(
                BasicConv(inch,outch,1),
                BasicConv(outch,inch,3)
            )
    
        def forward(self,x):
            return x+self.block(x)
    
    class CSPNetTest(nn.Module):
        def __init__(self):
            super(CSPNetTest, self).__init__()
            self.prelayer=nn.Sequential(
                BasicConv(3,32,3,1),
                BasicConv(32,64,3,2)
            )
            self.part1=BasicConv(64,64,1,1)
            self.part2=nn.Sequential(
                BasicConv(64, 64, 1, 1),
                Resblock(64,32),
                BasicConv(64, 64, 1, 1)
            )
        def forward(self,x):
            out1=self.prelayer(x)
            out2 = self.part1(out1)
    
            route1=out1
            out3=self.part2(route1)
    
            route2=torch.cat([out2,out3],1)
    
            return route2
    
    inpus=torch.randn(1,3,608,608)
    model=CSPNetTest()
    res=model(inpus)
    print(res.shape)#torch.Size([1, 128, 304, 304])

### ②、SPP ###

SPP全称为Spatial Pyramid Pooling ，即，空间金字塔池化，SPP论文详见这里：[https://arxiv.org/pdf/1406.4729.pdf][https_arxiv.org_pdf_1406.4729.pdf]，网络结构如下图所示。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU2MDQwMg_size_16_color_FFFFFF_t_70_pic_center 1][]

SPP网络用在YOLOv4中的目的是**增加网络的感受野**。实现是对layer107进行 5 × 5  、 9 × 9  、 13 × 13  的最大池化。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3MjY0Mzk3_size_16_color_FFFFFF_t_70 2][]

import torch
    import torch.nn as nn
    
    
    class SPP(nn.Module):
        def __init__(self):
            super(SPP, self).__init__()
            self.maxpool1=nn.MaxPool2d(13,1,6)
            self.maxpool2 = nn.MaxPool2d(9, 1, 4)
            self.maxpool3 = nn.MaxPool2d(5, 1, 2)
    
        def forward(self,x):
            pool1=self.maxpool1(x)
            pool2=self.maxpool2(x)
            pool3=self.maxpool3(x)
    
            return torch.cat([pool1,pool2,pool3,x],1)
    
    class testNet(nn.Module):
        def __init__(self):
            super(testNet, self).__init__()
            self.conv=nn.Sequential(
                nn.Conv2d(1024, 512, 1, 1),
                nn.LeakyReLU()
            )
            self.spp=SPP()
    
        def forward(self,x):
            x=self.conv(x)
            out=self.spp(x)
    
            return out
    
    inputs=torch.randn(1,1024,19,19)
    model=testNet()
    res=model(inputs)
    print(res.shape)#torch.Size([1, 2048, 19, 19])

### ③PAN ###

PANet(Path Aggregation Network , 路径聚合网络) 的论文详见这里[https://arxiv.org/pdf/1803.01534.pdf][https_arxiv.org_pdf_1803.01534.pdf]，网络结构如下图所示，与FPN相比，PANet 在UpSample之后又加了DownSample的操作。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU2MDQwMg_size_16_color_FFFFFF_t_70_pic_center 2][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3MjY0Mzk3_size_16_color_FFFFFF_t_70 3][]

import torch
    import torch.nn as nn
    
    class Upsample(nn.Module):
        def __init__(self,inch,outch):
            super(Upsample, self).__init__()
            self.upsample=nn.Sequential(
                nn.Conv2d(inch,outch,1),
                nn.Upsample(scale_factor=2,mode='nearest')
            )
    
        def forward(self,x):
            return self.upsample(x)
    
    
    class testNet(nn.Module):
        def __init__(self):
            super(testNet, self).__init__()
    
            self.conv1=nn.Sequential(
                nn.Conv2d(512,256,1,1),
                nn.LeakyReLU()
            )
            self.conv2 = nn.Sequential(
                nn.Conv2d(512, 256, 3, 2, 1),
                nn.LeakyReLU()
            )
            self.upsample=Upsample(256,256)
    
        def forward(self,x):
            out1=self.conv1(x)#torch.Size([1, 256, 38, 38])
            out2=self.conv2(x)#torch.Size([1, 256, 19, 19])
            up=self.upsample(out2)#torch.Size([1, 256, 38, 38])
    
            out=torch.cat([out1,up],1)
            return out
    
    
    
    
    
    inputs=torch.randn(1,512,38,38)
    model=testNet()
    res=model(inputs)
    print(res.shape)#torch.Size([1, 512, 38, 38])

### 5、FPN ###

论文：feature pyramid networks for object detection  
论文链接：[https://arxiv.org/abs/1612.03144][https_arxiv.org_abs_1612.03144]

FPN(**Feature Pyramid Networks,特征图金字塔网络**)算法大致结构如下：**一个自底向上的线路，一个自顶向下的线路，横向连接**（lateral connection）。图中放大的区域就是横向连接，这里1\*1的卷积核的主要作用是减少卷积核的个数，也就是减少了feature map的个数，并不改变feature map的尺寸大小。通过简单的网络连接改变，在基本不增加原有模型计算量的情况下，大幅度提升了小物体检测的性能。[参考][Link 4]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3MjY0Mzk3_size_16_color_FFFFFF_t_70 4][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3MjY0Mzk3_size_16_color_FFFFFF_t_70 5][]

参考：

[https://www.jianshu.com/p/ab8392ef3394][Link 1]

[https://blog.csdn.net/dz4543/article/details/90049377][https_blog.csdn.net_dz4543_article_details_90049377]

[https://blog.csdn.net/zhqh100/article/details/94737221][https_blog.csdn.net_zhqh100_article_details_94737221]

[https://www.cnblogs.com/shenpings1314/p/10468418.html][https_www.cnblogs.com_shenpings1314_p_10468418.html]

[https://www.cnblogs.com/fujian-code/p/7782669.html][https_www.cnblogs.com_fujian-code_p_7782669.html]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NlbmJpbnl1_size_16_color_FFFFFF_t_70_pic_center]: /images/20221119/7e775930308941dc8564da3b20d080f1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NlbmJpbnl1_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20200814034859953.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NlbmJpbnl1,size_16,color_FFFFFF,t_70#pic_center
[e94ecc6bbec06fb754a40f31ca05072a.png]: https://img-blog.csdnimg.cn/img_convert/e94ecc6bbec06fb754a40f31ca05072a.png
[Link 1]: https://www.jianshu.com/p/ab8392ef3394
[f8e203da22a08b4c1b9274f669c7749a.png]: https://img-blog.csdnimg.cn/img_convert/f8e203da22a08b4c1b9274f669c7749a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU2MDQwMg_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20200609151524354.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU2MDQwMg==,size_16,color_FFFFFF,t_70#pic_center
[Link 2]: https://blog.csdn.net/weixin_41560402/article/details/106119774
[CSPNet]: https://www.cnblogs.com/pprp/p/12566116.html
[Link 3]: https://www.cnblogs.com/pprp/p/12493845.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3MjY0Mzk3_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210125091956735.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3MjY0Mzk3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3MjY0Mzk3_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210125095446544.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3MjY0Mzk3,size_16,color_FFFFFF,t_70
[https_arxiv.org_pdf_1406.4729.pdf]: https://arxiv.org/pdf/1406.4729.pdf
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU2MDQwMg_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20200514174402114.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU2MDQwMg==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3MjY0Mzk3_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210125104220407.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3MjY0Mzk3,size_16,color_FFFFFF,t_70
[https_arxiv.org_pdf_1803.01534.pdf]: https://arxiv.org/pdf/1803.01534.pdf
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU2MDQwMg_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20200514180255816.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU2MDQwMg==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3MjY0Mzk3_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20210125112417213.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3MjY0Mzk3,size_16,color_FFFFFF,t_70
[https_arxiv.org_abs_1612.03144]: https://arxiv.org/abs/1612.03144
[Link 4]: https://blog.csdn.net/kk123k/article/details/86566954
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3MjY0Mzk3_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/2021012511505934.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3MjY0Mzk3,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3MjY0Mzk3_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20210125115125971.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3MjY0Mzk3,size_16,color_FFFFFF,t_70
[https_blog.csdn.net_dz4543_article_details_90049377]: https://blog.csdn.net/dz4543/article/details/90049377
[https_blog.csdn.net_zhqh100_article_details_94737221]: https://blog.csdn.net/zhqh100/article/details/94737221
[https_www.cnblogs.com_shenpings1314_p_10468418.html]: https://www.cnblogs.com/shenpings1314/p/10468418.html
[https_www.cnblogs.com_fujian-code_p_7782669.html]: https://www.cnblogs.com/fujian-code/p/7782669.html