神经网络学习小记录50——Pytorch EfficientNet模型的复现详解

我会带着你远行 2023-02-17 11:13 609阅读 0赞

### 神经网络学习小记录50——Pytorch EfficientNet模型的复现详解 ###

*  学习前言
 *  什么是EfficientNet模型
 *   *  EfficientNet模型的特点
     *  EfficientNet网络的结构
 *  EfficientNet网络部分实现代码

# 学习前言 #

也看看Pytorch版本的Efficientnet。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center]

# 什么是EfficientNet模型 #

2019年，谷歌新出EfficientNet，网络如其名，这个网络非常的有效率，怎么理解有效率这个词呢，我们从卷积神经网络的发展来看：  
从最初的VGG16发展到如今的Xception，人们慢慢发现，提高神经网络的性能不仅仅在于堆叠层数，更重要的几点是：

**1、网络要可以训练，可以收敛。  
2、参数量要比较小，方便训练，提高速度。  
3、创新神经网络的结构，学到更重要的东西。**

而EfficientNet很好的做到了这一点，它利用**更少的参数量（关系到训练、速度）得到最好的识别度（学到更重要的特点）**。

## EfficientNet模型的特点 ##

EfficientNet模型具有很独特的特点，这个特点是参考其它优秀神经网络设计出来的。经典的神经网络特点如下：  
1、**利用残差神经网络增大神经网络的深度，通过更深的神经网络实现特征提取。**  
2、**改变每一层提取的特征层数，实现更多层的特征提取，得到更多的特征，提升宽度。**  
3、**通过增大输入图片的分辨率也可以使得网络可以学习与表达的东西更加丰富，有利于提高精确度**。

EfficientNet就是将这三个特点结合起来，通过一起**缩放baseline模型**（**MobileNet中就通过缩放α实现缩放模型，不同的α有不同的模型精度，α=1时为baseline模型；ResNet其实也是有一个baseline模型，在baseline的基础上通过改变图片的深度实现不同的模型实现**），同时调整**深度**、**宽度**、**输入图片的分辨率**完成一个优秀的网络设计。

EfficientNet的效果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 1]  
在EfficientNet模型中，其使用一组固定的缩放系数统一缩放网络深度、宽度和分辨率。  
**假设想使用 2N倍的计算资源，我们可以简单的对网络深度扩大αN倍、宽度扩大βN 、图像尺寸扩大γN倍，这里的α,β,γ都是由原来的小模型上做微小的网格搜索决定的常量系数。**  
如图为EfficientNet的设计思路，从三个方面同时拓充网络的特性。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 2]

## EfficientNet网络的结构 ##

EfficientNet一共由Stem + 16个Blocks + Con2D + GlobalAveragePooling2D + Dense组成，其核心内容是16个Blocks，其它的结构与常规的卷积神经网络差距不大。  
此时展示的是EfficientNet-B0也就是EfficientNet的baseline的结构：  
![在这里插入图片描述][2019110409222792.png_pic_center]  
其中每个Block的的参数如下：

BlockArgs(kernel_size=3, num_repeat=1, input_filters=32, output_filters=16, expand_ratio=1, id_skip=True, stride=[1], se_ratio=0.25), 
    BlockArgs(kernel_size=3, num_repeat=2, input_filters=16, output_filters=24, expand_ratio=6, id_skip=True, stride=[2], se_ratio=0.25), 
    BlockArgs(kernel_size=5, num_repeat=2, input_filters=24, output_filters=40, expand_ratio=6, id_skip=True, stride=[2], se_ratio=0.25), 
    BlockArgs(kernel_size=3, num_repeat=3, input_filters=40, output_filters=80, expand_ratio=6, id_skip=True, stride=[2], se_ratio=0.25), 
    BlockArgs(kernel_size=5, num_repeat=3, input_filters=80, output_filters=112, expand_ratio=6, id_skip=True, stride=[1], se_ratio=0.25), 
    BlockArgs(kernel_size=5, num_repeat=4, input_filters=112, output_filters=192, expand_ratio=6, id_skip=True, stride=[2], se_ratio=0.25), 
    BlockArgs(kernel_size=3, num_repeat=1, input_filters=192, output_filters=320, expand_ratio=6, id_skip=True, stride=[1], se_ratio=0.25)]
    
    GlobalParams(batch_norm_momentum=0.99, batch_norm_epsilon=0.001, dropout_rate=0.2, num_classes=1000, width_coefficient=1.0, 
                depth_coefficient=1.0, depth_divisor=8, min_depth=None, drop_connect_rate=0.2, image_size=224)

Efficientnet-B0由1个Stem+16个大Blocks堆叠构成，16个大Blocks可以分为1、2、2、3、3、4、1个Block。**Block的通用结构如下，其总体的设计思路是Inverted residuals结构和残差结构，在3x3或者5x5网络结构前利用1x1卷积升维，在3x3或者5x5网络结构后增加了一个关于通道的注意力机制，最后利用1x1卷积降维后增加一个大残差边。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 3]  
**Block实现代码如下**：

class MBConvBlock(nn.Module):
        '''
        EfficientNet-b0:
        [BlockArgs(kernel_size=3, num_repeat=1, input_filters=32, output_filters=16, expand_ratio=1, id_skip=True, stride=[1], se_ratio=0.25), 
         BlockArgs(kernel_size=3, num_repeat=2, input_filters=16, output_filters=24, expand_ratio=6, id_skip=True, stride=[2], se_ratio=0.25), 
         BlockArgs(kernel_size=5, num_repeat=2, input_filters=24, output_filters=40, expand_ratio=6, id_skip=True, stride=[2], se_ratio=0.25), 
         BlockArgs(kernel_size=3, num_repeat=3, input_filters=40, output_filters=80, expand_ratio=6, id_skip=True, stride=[2], se_ratio=0.25), 
         BlockArgs(kernel_size=5, num_repeat=3, input_filters=80, output_filters=112, expand_ratio=6, id_skip=True, stride=[1], se_ratio=0.25), 
         BlockArgs(kernel_size=5, num_repeat=4, input_filters=112, output_filters=192, expand_ratio=6, id_skip=True, stride=[2], se_ratio=0.25), 
         BlockArgs(kernel_size=3, num_repeat=1, input_filters=192, output_filters=320, expand_ratio=6, id_skip=True, stride=[1], se_ratio=0.25)]
        
        GlobalParams(batch_norm_momentum=0.99, batch_norm_epsilon=0.001, dropout_rate=0.2, num_classes=1000, width_coefficient=1.0, 
                        depth_coefficient=1.0, depth_divisor=8, min_depth=None, drop_connect_rate=0.2, image_size=224)
        '''
        def __init__(self, block_args, global_params):
            super().__init__()
            self._block_args = block_args
            # 获得标准化的参数
            self._bn_mom = 1 - global_params.batch_norm_momentum
            self._bn_eps = global_params.batch_norm_epsilon
    
            # 注意力机制的缩放比例
            self.has_se = (self._block_args.se_ratio is not None) and (
                0 < self._block_args.se_ratio <= 1)
            # 是否需要短接边
            self.id_skip = block_args.id_skip 
    
            Conv2d = get_same_padding_conv2d(image_size=global_params.image_size)
    
            # 1x1卷积通道扩张
            inp = self._block_args.input_filters  # number of input channels
            oup = self._block_args.input_filters * self._block_args.expand_ratio  # number of output channels
            if self._block_args.expand_ratio != 1:
                self._expand_conv = Conv2d(
                    in_channels=inp, out_channels=oup, kernel_size=1, bias=False)
                self._bn0 = nn.BatchNorm2d(
                    num_features=oup, momentum=self._bn_mom, eps=self._bn_eps)
    
            # 深度可分离卷积
            k = self._block_args.kernel_size
            s = self._block_args.stride
            self._depthwise_conv = Conv2d(
                in_channels=oup, out_channels=oup, groups=oup,
                kernel_size=k, stride=s, bias=False)
            self._bn1 = nn.BatchNorm2d(
                num_features=oup, momentum=self._bn_mom, eps=self._bn_eps)
    
            # 注意力机制模块组，先进行通道数的收缩再进行通道数的扩张
            if self.has_se:
                num_squeezed_channels = max(
                    1, int(self._block_args.input_filters * self._block_args.se_ratio))
                self._se_reduce = Conv2d(
                    in_channels=oup, out_channels=num_squeezed_channels, kernel_size=1)
                self._se_expand = Conv2d(
                    in_channels=num_squeezed_channels, out_channels=oup, kernel_size=1)
    
            # 输出部分
            final_oup = self._block_args.output_filters
            self._project_conv = Conv2d(
                in_channels=oup, out_channels=final_oup, kernel_size=1, bias=False)
            self._bn2 = nn.BatchNorm2d(
                num_features=final_oup, momentum=self._bn_mom, eps=self._bn_eps)
            self._swish = MemoryEfficientSwish()
    
        def forward(self, inputs, drop_connect_rate=None):
            x = inputs
            if self._block_args.expand_ratio != 1:
                x = self._swish(self._bn0(self._expand_conv(inputs)))
    
            x = self._swish(self._bn1(self._depthwise_conv(x)))
    
            # 添加了注意力机制
            if self.has_se:
                x_squeezed = F.adaptive_avg_pool2d(x, 1)
                x_squeezed = self._se_expand(
                    self._swish(self._se_reduce(x_squeezed)))
                x = torch.sigmoid(x_squeezed) * x
    
            x = self._bn2(self._project_conv(x))
    
            # 满足以下条件才可以短接
            input_filters, output_filters = self._block_args.input_filters, self._block_args.output_filters
            if self.id_skip and self._block_args.stride == 1 and input_filters == output_filters:
                if drop_connect_rate:
                    x = drop_connect(x, p=drop_connect_rate,
                                     training=self.training)
                x = x + inputs  # skip connection
            return x
    
        def set_swish(self, memory_efficient=True):
            """Sets swish function as memory efficient (for training) or standard (for export)"""
            self._swish = MemoryEfficientSwish() if memory_efficient else Swish()

# EfficientNet网络部分实现代码 #

import torch
    from torch import nn
    from torch.nn import functional as F
    
    from nets.layers import (
        round_filters,
        round_repeats,
        drop_connect,
        get_same_padding_conv2d,
        get_model_params,
        efficientnet_params,
        load_pretrained_weights,
        Swish,
        MemoryEfficientSwish,
    )
    
    
    class MBConvBlock(nn.Module):
        '''
        EfficientNet-b0:
        [BlockArgs(kernel_size=3, num_repeat=1, input_filters=32, output_filters=16, expand_ratio=1, id_skip=True, stride=[1], se_ratio=0.25), 
         BlockArgs(kernel_size=3, num_repeat=2, input_filters=16, output_filters=24, expand_ratio=6, id_skip=True, stride=[2], se_ratio=0.25), 
         BlockArgs(kernel_size=5, num_repeat=2, input_filters=24, output_filters=40, expand_ratio=6, id_skip=True, stride=[2], se_ratio=0.25), 
         BlockArgs(kernel_size=3, num_repeat=3, input_filters=40, output_filters=80, expand_ratio=6, id_skip=True, stride=[2], se_ratio=0.25), 
         BlockArgs(kernel_size=5, num_repeat=3, input_filters=80, output_filters=112, expand_ratio=6, id_skip=True, stride=[1], se_ratio=0.25), 
         BlockArgs(kernel_size=5, num_repeat=4, input_filters=112, output_filters=192, expand_ratio=6, id_skip=True, stride=[2], se_ratio=0.25), 
         BlockArgs(kernel_size=3, num_repeat=1, input_filters=192, output_filters=320, expand_ratio=6, id_skip=True, stride=[1], se_ratio=0.25)]
        
        GlobalParams(batch_norm_momentum=0.99, batch_norm_epsilon=0.001, dropout_rate=0.2, num_classes=1000, width_coefficient=1.0, 
                        depth_coefficient=1.0, depth_divisor=8, min_depth=None, drop_connect_rate=0.2, image_size=224)
        '''
        def __init__(self, block_args, global_params):
            super().__init__()
            self._block_args = block_args
            # 获得标准化的参数
            self._bn_mom = 1 - global_params.batch_norm_momentum
            self._bn_eps = global_params.batch_norm_epsilon
    
            # 注意力机制的缩放比例
            self.has_se = (self._block_args.se_ratio is not None) and (
                0 < self._block_args.se_ratio <= 1)
            # 是否需要短接边
            self.id_skip = block_args.id_skip 
    
            Conv2d = get_same_padding_conv2d(image_size=global_params.image_size)
    
            # 1x1卷积通道扩张
            inp = self._block_args.input_filters  # number of input channels
            oup = self._block_args.input_filters * self._block_args.expand_ratio  # number of output channels
            if self._block_args.expand_ratio != 1:
                self._expand_conv = Conv2d(
                    in_channels=inp, out_channels=oup, kernel_size=1, bias=False)
                self._bn0 = nn.BatchNorm2d(
                    num_features=oup, momentum=self._bn_mom, eps=self._bn_eps)
    
            # 深度可分离卷积
            k = self._block_args.kernel_size
            s = self._block_args.stride
            self._depthwise_conv = Conv2d(
                in_channels=oup, out_channels=oup, groups=oup,
                kernel_size=k, stride=s, bias=False)
            self._bn1 = nn.BatchNorm2d(
                num_features=oup, momentum=self._bn_mom, eps=self._bn_eps)
    
            # 注意力机制模块组，先进行通道数的收缩再进行通道数的扩张
            if self.has_se:
                num_squeezed_channels = max(
                    1, int(self._block_args.input_filters * self._block_args.se_ratio))
                self._se_reduce = Conv2d(
                    in_channels=oup, out_channels=num_squeezed_channels, kernel_size=1)
                self._se_expand = Conv2d(
                    in_channels=num_squeezed_channels, out_channels=oup, kernel_size=1)
    
            # 输出部分
            final_oup = self._block_args.output_filters
            self._project_conv = Conv2d(
                in_channels=oup, out_channels=final_oup, kernel_size=1, bias=False)
            self._bn2 = nn.BatchNorm2d(
                num_features=final_oup, momentum=self._bn_mom, eps=self._bn_eps)
            self._swish = MemoryEfficientSwish()
    
        def forward(self, inputs, drop_connect_rate=None):
            x = inputs
            if self._block_args.expand_ratio != 1:
                x = self._swish(self._bn0(self._expand_conv(inputs)))
    
            x = self._swish(self._bn1(self._depthwise_conv(x)))
    
            # 添加了注意力机制
            if self.has_se:
                x_squeezed = F.adaptive_avg_pool2d(x, 1)
                x_squeezed = self._se_expand(
                    self._swish(self._se_reduce(x_squeezed)))
                x = torch.sigmoid(x_squeezed) * x
    
            x = self._bn2(self._project_conv(x))
    
            # 满足以下条件才可以短接
            input_filters, output_filters = self._block_args.input_filters, self._block_args.output_filters
            if self.id_skip and self._block_args.stride == 1 and input_filters == output_filters:
                if drop_connect_rate:
                    x = drop_connect(x, p=drop_connect_rate,
                                     training=self.training)
                x = x + inputs  # skip connection
            return x
    
        def set_swish(self, memory_efficient=True):
            """Sets swish function as memory efficient (for training) or standard (for export)"""
            self._swish = MemoryEfficientSwish() if memory_efficient else Swish()
    
    class EfficientNet(nn.Module):
        '''
        EfficientNet-b0:
        [BlockArgs(kernel_size=3, num_repeat=1, input_filters=32, output_filters=16, expand_ratio=1, id_skip=True, stride=[1], se_ratio=0.25), 
         BlockArgs(kernel_size=3, num_repeat=2, input_filters=16, output_filters=24, expand_ratio=6, id_skip=True, stride=[2], se_ratio=0.25), 
         BlockArgs(kernel_size=5, num_repeat=2, input_filters=24, output_filters=40, expand_ratio=6, id_skip=True, stride=[2], se_ratio=0.25), 
         BlockArgs(kernel_size=3, num_repeat=3, input_filters=40, output_filters=80, expand_ratio=6, id_skip=True, stride=[2], se_ratio=0.25), 
         BlockArgs(kernel_size=5, num_repeat=3, input_filters=80, output_filters=112, expand_ratio=6, id_skip=True, stride=[1], se_ratio=0.25), 
         BlockArgs(kernel_size=5, num_repeat=4, input_filters=112, output_filters=192, expand_ratio=6, id_skip=True, stride=[2], se_ratio=0.25), 
         BlockArgs(kernel_size=3, num_repeat=1, input_filters=192, output_filters=320, expand_ratio=6, id_skip=True, stride=[1], se_ratio=0.25)]
        
        GlobalParams(batch_norm_momentum=0.99, batch_norm_epsilon=0.001, dropout_rate=0.2, num_classes=1000, width_coefficient=1.0, 
                        depth_coefficient=1.0, depth_divisor=8, min_depth=None, drop_connect_rate=0.2, image_size=224)
        '''
        def __init__(self, blocks_args=None, global_params=None):
            super().__init__()
            assert isinstance(blocks_args, list), 'blocks_args should be a list'
            assert len(blocks_args) > 0, 'block args must be greater than 0'
            self._global_params = global_params
            self._blocks_args = blocks_args
            # 获得一种卷积方法
            Conv2d = get_same_padding_conv2d(image_size=global_params.image_size)
    
            # 获得标准化的参数
            bn_mom = 1 - self._global_params.batch_norm_momentum
            bn_eps = self._global_params.batch_norm_epsilon
    
            # 网络主干部分开始
            # 设定输入进来的是RGB三通道图像
            in_channels = 3  
            # 利用round_filters可以使得通道数在扩张的时候可以被8整除
            out_channels = round_filters(32, self._global_params)
    
            # 卷积+标准化
            self._conv_stem = Conv2d(
                in_channels, out_channels, kernel_size=3, stride=2, bias=False)
            self._bn0 = nn.BatchNorm2d(
                num_features=out_channels, momentum=bn_mom, eps=bn_eps)
    
            # 对每个block的参数进行修改
            self._blocks = nn.ModuleList([])
            for i in range(len(self._blocks_args)):
                # 对每个block的参数进行修改，根据所选的efficient版本进行修改
                self._blocks_args[i] = self._blocks_args[i]._replace(
                    input_filters=round_filters(
                        self._blocks_args[i].input_filters, self._global_params),
                    output_filters=round_filters(
                        self._blocks_args[i].output_filters, self._global_params),
                    num_repeat=round_repeats(
                        self._blocks_args[i].num_repeat, self._global_params)
                )
    
                # 第一次大的Block里面的卷积需要考虑步长和输入进来的通道数！
                self._blocks.append(MBConvBlock(self._blocks_args[i], self._global_params))
    
                if self._blocks_args[i].num_repeat > 1:
                    self._blocks_args[i] = self._blocks_args[i]._replace(input_filters=self._blocks_args[i].output_filters, stride=1)
                for _ in range(self._blocks_args[i].num_repeat - 1):
                    self._blocks.append(MBConvBlock(self._blocks_args[i], self._global_params))
    
            # 增加了head部分
            in_channels = self._blocks_args[len(self._blocks_args)-1].output_filters
            out_channels = round_filters(1280, self._global_params)
    
            # 卷积+标准化
            self._conv_head = Conv2d(in_channels, out_channels, kernel_size=1, bias=False)
            self._bn1 = nn.BatchNorm2d(num_features=out_channels, momentum=bn_mom, eps=bn_eps)
    
            # 最后的线性全连接层
            self._avg_pooling = nn.AdaptiveAvgPool2d(1)
            self._dropout = nn.Dropout(self._global_params.dropout_rate)
            self._fc = nn.Linear(out_channels, self._global_params.num_classes)
            # 进行swish激活函数
            self._swish = MemoryEfficientSwish()
    
        def set_swish(self, memory_efficient=True):
            """Sets swish function as memory efficient (for training) or standard (for export)"""
            # swish函数
            self._swish = MemoryEfficientSwish() if memory_efficient else Swish()
            for block in self._blocks:
                block.set_swish(memory_efficient)
    
        def extract_features(self, inputs):
            """ Returns output of the final convolution layer """
    
            # Stem
            x = self._swish(self._bn0(self._conv_stem(inputs)))
    
            # Blocks
            for idx, block in enumerate(self._blocks):
                drop_connect_rate = self._global_params.drop_connect_rate
                if drop_connect_rate:
                    drop_connect_rate *= float(idx) / len(self._blocks)
                x = block(x, drop_connect_rate=drop_connect_rate)
            # Head
            x = self._swish(self._bn1(self._conv_head(x)))
    
            return x
    
        def forward(self, inputs):
            """ Calls extract_features to extract features, applies final linear layer, and returns logits. """
            bs = inputs.size(0)
            # Convolution layers
            x = self.extract_features(inputs)
    
            # Pooling and final linear layer
            x = self._avg_pooling(x)
            x = x.view(bs, -1)
            x = self._dropout(x)
            x = self._fc(x)
            return x
    
        @classmethod
        def from_name(cls, model_name, override_params=None):
            cls._check_model_name_is_valid(model_name)
            blocks_args, global_params = get_model_params(model_name, override_params)
            return cls(blocks_args, global_params)
    
        @classmethod
        def from_pretrained(cls, model_name, load_weights=True, advprop=True, num_classes=1000, in_channels=3):
            model = cls.from_name(model_name, override_params={
        'num_classes': num_classes})
            if load_weights:
                load_pretrained_weights(model, model_name, load_fc=(num_classes == 1000), advprop=advprop)
            if in_channels != 3:
                Conv2d = get_same_padding_conv2d(image_size = model._global_params.image_size)
                out_channels = round_filters(32, model._global_params)
                model._conv_stem = Conv2d(in_channels, out_channels, kernel_size=3, stride=2, bias=False)
            return model
    
        @classmethod
        def get_image_size(cls, model_name):
            cls._check_model_name_is_valid(model_name)
            _, _, res, _ = efficientnet_params(model_name)
            return res
    
        @classmethod
        def _check_model_name_is_valid(cls, model_name):
            """ Validates model name. """
            valid_models = ['efficientnet-b'+str(i) for i in range(9)]
            if model_name not in valid_models:
                raise ValueError('model_name should be one of: ' + ', '.join(valid_models))

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20190723144346254.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 1]: https://img-blog.csdnimg.cn/20191103203721126.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 2]: https://img-blog.csdnimg.cn/20191103204155200.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA==,size_16,color_FFFFFF,t_70#pic_center
[2019110409222792.png_pic_center]: https://img-blog.csdnimg.cn/2019110409222792.png#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/20200613160519287.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA==,size_16,color_FFFFFF,t_70#pic_center