（RegionProposal Network)RPN网络结构及详解

梦里梦外; 2024-04-17 19:17 68阅读 0赞

本文链接：https://blog.csdn.net/qq\_36269513/article/details/80421990  
**RPN(RegionProposal Network)区域生成网络  
Faster-RCNN的核心。在这里整理。**

**1.anchors。**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70]  
思路：

1、先通过conv层+pooling层+relu层，可以是vgg，得到feature maps。

2、在feature maps上提取对应的图。在第一步基础上，先通过rpn生成region proposals。通过softmax判断anchors（9个框），是foreground还是background，再通过bounding box regression 进行修正anchors，也就是进一步确定proposals。

3、目的是为了得到proposals feature maps，提取框的特征图，这一步是为了下面的分类做准备，也就是先得到框图在分类。这一步先通过上面得到的proposals，和roi pooling，提取proposals feature maps。

4、分类。用proposals feature maps和一开始的proposals判断类别。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70 1]  
1、一个图片从由p*q大小，变为m*n大小（600*1000），进入网络，经过13个conv，13个relu，4个pooling。得到feature maps（40*60\*256）。

2、先经过3*3conv，经过1*1conv，分成foreground和background，上面一条线是通过softmax分类anchor，获得foreground和background，下面计算anchor的boundingboxregression偏移情况。然后计算出来proposals。

3、roi pooling，用proposals从最一开始的feature maps，通过全连接和softmax，分类。

步骤：

1、卷积层

包括conv，relu，pooling。以vgg16为例，13个conv参数为kernelsize为3*3，pad为1，4个pooling为2*2，stride为2，一个图形进去网络出来后大小为m/16 ,n/16的feature maps。

2、region proposal networks（RPN）  
1、一个图片从由p*q大小，变为m*n大小（600*1000），进入网络，经过13个conv，13个relu，4个pooling。得到feature maps（40*60\*256）。

3、roi pooling，用proposals从最一开始的feature maps，通过全连接和softmax，分类。

步骤：

1、卷积层

包括conv，relu，pooling。以vgg16为例，13个conv参数为kernelsize为3*3，pad为1，4个pooling为2*2，stride为2，一个图形进去网络出来后大小为m/16 ,n/16的feature maps。

2、region proposal networks（RPN）  
![在这里插入图片描述][20200208171716969.png]

*  上面一层目的是为了完成分类anchors（9个框），以获得foreground和background，目的是留着foreground。
 *  下面是对anchors进行bounding box regression，为了得到精准的参数，可以帮助后面得到精准的proposal。
 *  最后proposal是为了整合上面两个步骤得到proposal。

从第一层说，进入3*3前图形是m/16 ,n/16的feature maps，进行3*3卷积应该是为了更好融合每个点周围的信息，每个点都有9个anchors，如下所示：每个点都有256-d，每个点都要对框分fore和back，为2个维度，所以为2k，k为9个框，所以每个点输出为W*H*18。同理回归是需要四个值定框，分别为左上右下，4个维度，所以为4k，为W*H*36。虽然文章里面有些到，但是其实在程序里面没有这样的内容，找不到所谓的框和所谓框的四个维度。

**proposals layer 3个输入，一个是分类器结果foreground，一个是anchor回归结果reg，还有一个是im-info，就是把图像进行了缩减后，进行proposal layer。**

1、先再生成anchor，对做reg回归。

2、按照输入foreground softmax scores对anchor排序。目的找到最优anchor（2000个）。

3、通过feat\_stride和im\_info，把anchor映射回原图。

4、nms。

5、按照nms由大到小排序foreground anchors。提取top作为结果输出proposal（256个）。

**from：https://blog.csdn.net/N\_Sapientia/article/details/81487968**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70 2]  
这里介绍一下分类层中的两个reshape操作：

对于cls层，使用1*1的卷积操作输出了18（9个anchor*2类fg/bg）个通道的feature map,大小不变。而对于regression层，也使用1*1的卷积层输出了36(4*9个anchor)个通道的feature map，大小不变。

对于cls层后又接了一个reshape层，其实只是为了便于softmax分类，这就要从caffe的实现形式说起了。在caffe基本数据结构blob中以如下形式保存数据：blob=\[batch\_size, channel，height，width\]

对应至上面的保存bg/fg anchors的矩阵，其在caffe blob中的存储形式为\[1, 2*9, H, W\]。而在softmax分类时需要进行fg/bg二分类，所以reshape layer会将其变为\[1, 2, 9*H, W\]大小，即单独“腾空”出来一个维度以便softmax分类，之后再reshape回复原状。

![在这里插入图片描述][20200208172048455.png]  
从中其实我们也能发现，对于rpn每个点的18个输出通道，前9个为背景的预测分数，而后9个为前景的预测分数。

对于regression，不需要这样的操作，那么他的36个通道是不是也是如上面18个通道那样呢？即第一个9通道为dx,第二个为dy,第三个为dw，第五个是dh。还是我们比较容易想到的那种,即第一个通道是第一个盒子的回归量(dx1,dy1,dw1,dh1),第二个为(dx2,dy2,dw,2,dh2)…。待后面查看对应的bbox\_targets就知道了

正如图上所示，我们还需要准备一个层rpn-data

layer {
      name: 'rpn-data'
      type: 'Python'
      bottom: 'rpn_cls_score'
      bottom: 'gt_boxes'
      bottom: 'im_info'
      bottom: 'data'
      top: 'rpn_labels'
      top: 'rpn_bbox_targets'
      top: 'rpn_bbox_inside_weights'
      top: 'rpn_bbox_outside_weights'
      python_param {
        module: 'rpn.anchor_target_layer'
        layer: 'AnchorTargetLayer'
        param_str: "'feat_stride': 16"
      }
    }

这一层输入四个量：data,gt\_boxes,im\_info,rpn\_cls\_score,其中前三个是我们在前面说过的，

data: 1*3*600*1000  
gt\_boxes: N*5, N为groundtruth box的个数，每一行为(x1, y1, x2, y2, cls) ，而且这里的gt\_box是经过缩放的。  
im\_info： 1\*3 （h,w,scale）

rpn\_cls\_score是cls层输出的18通道，shape可以看成是1*18*H\*W.

输出为4个量：

rpn\_labels ： (1, 1, 9 \* height, width)

rpn\_bbox\_targets（回归目标）： (1, 36，height, width)

rpn\_bbox\_inside\_weights（内权重）：(1, 36，height, width)

rpn\_bbox\_outside\_weights（外权重）：(1, 36，height, width)

通俗地来讲，这一层产生了具体的anchor坐标，并与groundtruth box进行了重叠度计算，输出了kabel与回归目标。

regression可以利用rpn_bbox_pred，rpn_bbox_targets，rpn_bbox_inside_weights，rpn_bbox_outside_weights计算SmoothL1Loss，输出rpn_loss_bbox。

回到我们之前有一个问题rpn\_bbox\_pred的shape怎么构造的。其实从rpn\_bbox\_targets的生成过程中可以推断出应该采用后一种，即第一个盒子的回归量(dx1,dy1,dw1,dh1),第二个为(dx2,dy2,dw,2,dh2)…，这样顺序着来。

from：https://blog.csdn.net/alibabazhouyu/article/details/80875383

## RPN结构流程图： ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70 3]  
Note：

*  只有在train时，cls+reg才能得到强监督信息(来源于ground truth)。即ground  
    truth会告诉cls+reg结构，哪些才是真的前景，从而引导cls+reg结构学得正确区分前后景的能力；在测试阶段，就要靠cls+reg自力更生了。
 *  在train阶段，会输出约2000个proposal，但只会抽取其中256个proposal来训练RPN的cls+reg结构；到了测试阶段，则直接输出最高score的300个proposal。此时由于没有了监督信息，所有RPN**并不知道这些proposal是否为前景**，整个过程只是惯性地推送一波无tag的proposal给后面的Fast  
    R-CNN。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70 4]

1、在 RPN头部 ，通过以下结构生成 anchor（其实就是一堆有编号有坐标的bbox）；

2、在 RPN中部， 分类分支（cls） 和 边框回归分支（bbox reg） 分别对这堆anchor进行计算。Note： two stage型的检测算法在RPN 之后 还会进行 再一次 的 分类任务 和 边框回归任务，以进一步提升检测精度；

3、在 RPN末端，通过对 两个分支的结果进行汇总，来实现对anchor的 初步筛除（先剔除越界的anchor，再根据cls结果通过NMS去重）和 初步偏移（根据bbox reg结果），此时输出的都改头换面叫 Proposal 。

**补充一点，全部anchors拿去训练太多了，训练程序会在合适的anchors中随机选取128个postive anchors+128个negative anchors进行训练。**

\-------------------------------------------------------分割线-------------------------------------------------------------------

以上是传统的RPN，下面是Faster R-CNN 的RPN部分。

**3.bounding box regression**

前2.）中已经计算出foreground anchors，使用bounding box regression回归得到预设anchor-box到ground-truth-box之间的变换参数，即平移（dx和dy）和伸缩参数（dw和dh），由此得到初步确定proposal。

如图9所示绿色框为飞机的Ground Truth(GT)，红色为提取的foreground anchors，那么即便红色的框被分类器识别为飞机，但是由于红色的框定位不准，这张图相当于没有正确的检测出飞机。所以我们希望采用一种方法对红色的框进行微调，使得foreground anchors和GT更加接近。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70 5]

图9

缩进对于窗口一般使用四维向量(x, y, w, h)表示，分别表示窗口的中心点坐标和宽高。对于图 10，红色的框A代表原始的Foreground Anchors，绿色的框G代表目标的GT，我们的目标是寻找一种关系，使得输入原始的anchor A经过映射得到一个跟真实窗口G更接近的回归窗口G’，即：给定A=(Ax, Ay, Aw, Ah)，寻找一种映射f，使得f(Ax, Ay, Aw, Ah)=(G’x, G’y, G’w, G’h)，其中(G’x, G’y, G’w, G’h)≈(Gx, Gy, Gw, Gh)。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70 6]

图10

那么经过何种变换才能从图6中的A变为G’呢？ 比较简单的思路就是:

缩进 1. 先做平移  
![在这里插入图片描述][20190830144610681.png]

缩进 2. 再做缩放  
![在这里插入图片描述][20190830144617545.png]

缩进观察上面4个公式发现，需要学习的是dx(A)，dy(A)，dw(A)，dh(A)这四个变换。当输入的anchor与GT相差较小时，可以认为这种变换是一种线性变换， 那么就可以用线性回归来建模对窗口进行微调（注意，只有当anchors和GT比较接近时，才能使用线性回归模型，否则就是复杂的非线性问题了）。对应于Faster RCNN原文，平移量(tx, ty)与尺度因子(tw, th)如下：  
![在这里插入图片描述][2019083014462614.png]

（后两个公式写错了，是tw,th）

缩进接下来的问题就是如何通过线性回归获得dx(A)，dy(A)，dw(A)，dh(A)了。线性回归就是给定输入的特征向量X, 学习一组参数W, 使得经过线性回归后的值跟真实值Y（即GT）非常接近，即Y=WX。对于该问题，输入X是一张经过卷积获得的feature map，定义为Φ；同时还有训练传入的GT，即(tx, ty, tw, th)。输出是dx(A)，dy(A)，dw(A)，dh(A)四个变换。那么目标函数可以表示为：![在这里插入图片描述][20190830144635731.png]

其中Φ(A)是对应anchor的feature map组成的特征向量，w是需要学习的参数，d(A)是得到的预测值（\*表示 x，y，w，h，也就是每一个变换对应一个上述目标函数）。为了让预测值(tx, ty, tw, th)与真实值最小，得到损失函数：  
![在这里插入图片描述][2019083014465650.png]  
函数优化目标为：

![在这里插入图片描述][20190830144706449.png]

Boundingbox regression原理http://blog.csdn.net/elaine\_bao/article/details/60469036

4.将预proposal利用feat\_stride和im\_info将anchors映射回原图，判断预proposal是否大范围超过边界，剔除严重超出边界的。

按照softmax score进行从大到小排序，提取前2000个预proposal，对这个2000个进行NMS(非极大值抑制)，将得到的再次进行排序，输出300个proposal。

**NMS（非极大值抑制）**

由于锚点经常重叠，因此建议最终也会在同一个目标上重叠。为了解决重复建议的问题，我们使用一个简单的算法，称为非极大抑制（NMS）。NMS 获取按照分数排序的建议列表并对已排序的列表进行迭代，丢弃那些 IoU 值大于某个预定义阈值的建议，并提出一个具有更高分数的建议。总之，抑制的过程是一个迭代-遍历-消除的过程。如下图所示：

*  将所有候选框的得分进行排序，选中最高分及其所对应的BB；

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70 7]

*  遍历其余的框，如果它和当前最高得分框的重叠面积大于一定的阈值，我们将其删除。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70 8]

图11

*  从没有处理的框中继续选择一个得分最高的，重复上述过程。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70 9]

框架流程：from:https://blog.csdn.net/zjucor/article/details/78232024

我的这个可以看到具体数据流动情况。

layer{
    	name:"data"
        top:"data"
        type:"Input"
        input_param{
        	shape{ dim: 1 dim: 3 dim: 224 dim: 224}
        }
    }
    #========= conv1-conv5 ============
     
    layer {
    	name: "conv1"
    	type: "Convolution"
    	bottom: "data"
    	top: "conv1" 
    	param { lr_mult: 1.0 }
    	param { lr_mult: 2.0 }
    	convolution_param {
    		num_output: 96
    		kernel_size: 7
    		pad: 3  
    		stride: 2
    	}
    }
    layer {
    	name: "relu1"
    	type: "ReLU"
    	bottom: "conv1"
    	top: "conv1"
    }
    layer {
    	name: "norm1"
    	type: "LRN"
    	bottom: "conv1"
    	top: "norm1" 
    	lrn_param {
    		local_size: 3
    		alpha: 0.00005
    		beta: 0.75
    		norm_region: WITHIN_CHANNEL
        engine: CAFFE
    	}
    }
    layer {
    	name: "pool1"
    	type: "Pooling"
    	bottom: "norm1"
    	top: "pool1"
    	pooling_param {
    		kernel_size: 3
    		stride: 2
    		pad: 1
    		pool: MAX
    	}
    }
    layer {
    	name: "conv2"
    	type: "Convolution"
    	bottom: "pool1"
    	top: "conv2"
    	param { lr_mult: 1.0 }
    	param { lr_mult: 2.0 }
    	convolution_param {
    		num_output: 256
    		kernel_size: 5
    		pad: 2
    		stride: 2
    	}
    }
    layer {
    	name: "relu2"
    	type: "ReLU"
    	bottom: "conv2"
    	top: "conv2"
    }
    layer {
    	name: "norm2"
    	type: "LRN"
    	bottom: "conv2"
    	top: "norm2"
    	lrn_param {
    		local_size: 3
    		alpha: 0.00005
    		beta: 0.75
    		norm_region: WITHIN_CHANNEL
        engine: CAFFE
    	}
    }
    layer {
    	name: "pool2"
    	type: "Pooling"
    	bottom: "norm2"
    	top: "pool2"
    	pooling_param {
    		kernel_size: 3
    		stride: 2
    		pad: 1
    		pool: MAX
    	}
    }
    layer {
    	name: "conv3"
    	type: "Convolution"
    	bottom: "pool2"
    	top: "conv3"
    	param { lr_mult: 1.0 }
    	param { lr_mult: 2.0 }
    	convolution_param {
    		num_output: 384
    		kernel_size: 3
    		pad: 1
    		stride: 1
    	}
    }
    layer {
    	name: "relu3"
    	type: "ReLU"
    	bottom: "conv3"
    	top: "conv3"
    }
    layer {
    	name: "conv4"
    	type: "Convolution"
    	bottom: "conv3"
    	top: "conv4"
    	param { lr_mult: 1.0 }
    	param { lr_mult: 2.0 }
    	convolution_param {
    		num_output: 384
    		kernel_size: 3
    		pad: 1
    		stride: 1
    	}
    }
    layer {
    	name: "relu4"
    	type: "ReLU"
    	bottom: "conv4"
    	top: "conv4"
    }
    layer {
    	name: "conv5"
    	type: "Convolution"
    	bottom: "conv4"
    	top: "conv5"
    	param { lr_mult: 1.0 }
    	param { lr_mult: 2.0 }
    	convolution_param {
    		num_output: 256
    		kernel_size: 3
    		pad: 1
    		stride: 1
    	}
    }
    layer {
    	name: "relu5"
    	type: "ReLU"
    	bottom: "conv5"
    	top: "conv5"
    }
     
     
    layer {
      name: "rpn_conv1"
      type: "Convolution"
      bottom: "conv5"
      top: "rpn_conv1"
      param { lr_mult: 1.0 }
      param { lr_mult: 2.0 }
      convolution_param {
        num_output: 256
        kernel_size: 3 pad: 1 stride: 1
        weight_filler { type: "gaussian" std: 0.01 }
        bias_filler { type: "constant" value: 0 }
      }
    }
    layer {
      name: "rpn_relu1"
      type: "ReLU"
      bottom: "rpn_conv1"
      top: "rpn_conv1"
    }
    layer {
      name: "rpn_cls_score"
      type: "Convolution"
      bottom: "rpn_conv1"
      top: "rpn_cls_score"
      param { lr_mult: 1.0 }
      param { lr_mult: 2.0 }
      convolution_param {
        num_output: 18   
        kernel_size: 1 pad: 0 stride: 1 
        weight_filler { type: "gaussian" std: 0.01 }
        bias_filler { type: "constant" value: 0 }
      }
    }
    layer {
      name: "rpn_bbox_pred"
      type: "Convolution"
      bottom: "rpn_conv1"
      top: "rpn_bbox_pred"
      param { lr_mult: 1.0 }
      param { lr_mult: 2.0 }
      convolution_param {
        num_output: 36  
        kernel_size: 1 pad: 0 stride: 1
        weight_filler { type: "gaussian" std: 0.01 }
        bias_filler { type: "constant" value: 0 }
      }
    }
    layer {
       bottom: "rpn_cls_score"
       top: "rpn_cls_score_reshape" 
       name: "rpn_cls_score_reshape"
       type: "Reshape"
       reshape_param { shape { dim: 0 dim: 2 dim: -1 dim: 0 } }
    }
    layer {
      name: 'rpn-data'
      type: 'Python'
      bottom: 'rpn_cls_score'
      bottom: 'gt_boxes'
      bottom: 'im_info'
      bottom: 'data'
      top: 'rpn_labels'
      top: 'rpn_bbox_targets'
      top: 'rpn_bbox_inside_weights'
      top: 'rpn_bbox_outside_weights'
      python_param {
        module: 'rpn.anchor_target_layer'
        layer: 'AnchorTargetLayer'
        param_str: "'feat_stride': 16"
      }
    }
    layer {
      name: "rpn_loss_cls"
      type: "SoftmaxWithLoss" 
      bottom: "rpn_cls_score_reshape"
      bottom: "rpn_labels"
      propagate_down: 1
      propagate_down: 0
      top: "rpn_cls_loss"
      loss_weight: 1
      loss_param {
        ignore_label: -1
        normalize: true
      }
    }
    layer {
      name: "rpn_loss_bbox"
      type: "SmoothL1Loss" 
      bottom: "rpn_bbox_pred"
      bottom: "rpn_bbox_targets"
      bottom: "rpn_bbox_inside_weights"
      bottom: "rpn_bbox_outside_weights"
      top: "rpn_loss_bbox"
      loss_weight: 1
      smooth_l1_loss_param { sigma: 3.0 }
    }
     
     
    layer {
      name: "dummy_roi_pool_conv5"
      type: "DummyData"
      top: "dummy_roi_pool_conv5"
      dummy_data_param {
        shape { dim: 1 dim: 9216 }
        data_filler { type: "gaussian" std: 0.01 }
      }
    }
    layer {
      name: "fc6"
      type: "InnerProduct"
      bottom: "dummy_roi_pool_conv5"
      top: "fc6"
      param { lr_mult: 0 decay_mult: 0 }
      param { lr_mult: 0 decay_mult: 0 }
      inner_product_param {
        num_output: 4096
      }
    }
    layer {
      name: "relu6"
      type: "ReLU"
      bottom: "fc6"
      top: "fc6"
    }
    layer {
      name: "fc7"
      type: "InnerProduct"
      bottom: "fc6"
      top: "fc7"
      param { lr_mult: 0 decay_mult: 0 }
      param { lr_mult: 0 decay_mult: 0 }
      inner_product_param {
        num_output: 4096
      }
    }
    layer {
      name: "silence_fc7"
      type: "Silence"
      bottom: "fc7"
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/7c3150ca14a147c292d7a0af85b2ec36.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/e5fbfcdd6bad4706bfa1ed4932d448d7.png
[20200208171716969.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/fed66f5716d04c828a2b2356b32f5a01.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/76dc4fe620d1445080be9221d95133c8.png
[20200208172048455.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/6a63da15049a4c7c80dd821cf1eb04e2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/d43c609a8f414dbe95de0cddb8a40638.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/e1c5543f56954253ae3a3d26bbf38b67.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/e859875473e94c3a8972d7c652250d02.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/4d9fbfefd10f436aa1e6e6a1165d0d80.png
[20190830144610681.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/1dc1d5d5a3404b548eb56487f9f04cdd.png
[20190830144617545.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/2847324bb55548dd8ed075c6f0e4ed47.png
[2019083014462614.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/d2ebe95677914e65ad6f29024406af5a.png
[20190830144635731.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/00cad94cea7f42ad96deeefa927a6536.png
[2019083014465650.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/aaa8b24db63540e582281c68f213504d.png
[20190830144706449.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/8f5c5b7f08284b60adf52fc93a68481b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70 7]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/2fce97d1bf3542b5b9b0d5111e5d8024.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70 8]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/b8419bc30daf48cf97fb5780c2e16f73.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5ODUyNjc2_size_16_color_FFFFFF_t_70 9]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/78b9e247899c4715b0252880b9cdf35a.png