【SCRDet++论文解读】模型部分：特征提取 ResNet/FPN + 实例去噪 + 候选区域生成 RPN + 回归分类 RoI Warping

浅浅的花香味﹌ 2022-11-14 10:21 144阅读 0赞

### 【SCRDet++论文解读】 模型部分 ###

*  一、实例去噪
 *  二、候选区域生成网络
 *  三、回归分类

SCR Det++ 的模型结构是基于 Faster R-CNN 设计的，包括4部分，如下图所示：

![SCR Det++ 模型结构][SCR Det_]

1.  用于进行**特征提取**的基础网络（basic embodiment for feature extraction）。以**ResNet**为基础，添加了**特征金字塔（FPN）** 以进行多尺度特征融合。
2.  用于消除实例噪声的**实例级去噪**网络（instance-level denoising module for suppressing instance noise）
3.  用于生成五参数定义的旋转候选框的**候选区域生成**网络（RPN）。
4.  用于产生**类别分数**和**预测边界框**的部分（the ‘class+box’ branch for predicting classification score and bounding box position）

--------------------

论文中的4部分分别是：特征提取、图像级去噪、实例级去噪以及回归分类，这里划分成这4部分的原因有3个：

1. 为了更好的与 Faster R-CNN 模型结构进行对比；  
2. 因为图像级去噪的效果可以由实例级去噪达到，所以图像级去噪模块可省，就不需要体现在模型主要结构上；  
3. 代码中没有图像级去噪的部分。  
![Faster R-CNN 模型结构][Faster R-CNN]

--------------------

# 一、实例去噪 #

模块结构如下图所示：  
![在这里插入图片描述][2021042409463818.png]  
对 **FPN的每一层**，进行如下步骤：

1.  首先采用**N个空洞卷积和一个 1×1卷积**扩大感受野
2.  通过两个并行的 1×1 卷积层得到两个输出，**其中一个**输出是像素级标注，用以引导**另一个输出**生成**用于去噪的权重特征图**（denosing feature map）
3.  将用于去噪的权重特征图与原特征图通过**矩阵的点运算**进行融合，得到根据物体类别进行解耦后的**层次特征图**

代码：

# 上述步骤1：通过N个dilated convolutions 和一个 1×1卷积，扩大特征图感受野
    def enrich_semantics_supervised(net, channels, num_layer, scope):
        with tf.variable_scope(scope):
            for _ in range(num_layer-1):
                net = slim.conv2d(net, num_outputs=channels, kernel_size=[3, 3], stride=1, rate=2, padding="SAME")  # rate：对于使用空洞卷积的膨胀率
    
            net = slim.conv2d(net, num_outputs=channels, kernel_size=[3, 3], stride=1, rate=4, padding="SAME")
            net = slim.conv2d(net, num_outputs=channels, kernel_size=[1, 1], stride=1, padding="SAME")
            return net
            
    # 上述步骤 2：产生两个输出
    def generate_mask(net, num_layer, level_name):
        # num_layer个 Dilated/Atrous convs，扩大感受野
        G = enrich_semantics_supervised(net=net,
                                        num_layer=num_layer,
                                        channels=256, scope="enrich_%s" % level_name)
        # 这个过程有两个 output：
        # 第一个 output 的作用是形成 W×H×(C+1)的"像素级标注"
        last_dim = 2 if cfgs.BINARY_MASK else cfgs.CLASS_NUM + 1
        mask = slim.conv2d(G, num_outputs=last_dim, kernel_size=[1, 1], stride=1, padding="SAME",
                           activation_fn=None,
                           scope='gmask_%s' % level_name)   # shape=(W, H, C+1)
    	
    	# 第二个 output 是在第一个 output 的引导下，成为一个 denosing feature map
        act_fn = tf.nn.sigmoid if cfgs.SIGMOID_ON_DOT else None
        dot_layer = slim.conv2d(G, num_outputs=256, kernel_size=[1, 1], stride=1, padding="SAME",
                                activation_fn=act_fn,
                                scope='gdot_%s' % level_name)   # shape=(W, H, 256)
    
        return G, mask, dot_layer
        
    mask_list = []
    with tf.variable_scope("enrich_semantics"):
        with slim.arg_scope([slim.conv2d], weights_regularizer=slim.l2_regularizer(cfgs.WEIGHT_DECAY),
                            normalizer_fn=None):
            for i, l_name in enumerate(cfgs.GENERATE_MASK_LIST):
                # 返回值是 W×H×256的G、W×H×(C+1)的mask、W×H×256的dot_layer
                G, mask, dot_layer = generate_mask(net=pyramid_dict[l_name],
                                                   num_layer=cfgs.ADDITION_LAYERS[i],
                                                   level_name=l_name)
                add_heatmap(G, name="MASK/G_%s" % l_name)
                add_heatmap(mask, name="MASK/mask_%s" % l_name)
                # 上述步骤3：将 denosing feature map 和 original feature map 使用点乘的方式融合
                if cfgs.MASK_ACT_FET:
                    pyramid_dict[l_name] = pyramid_dict[l_name] * dot_layer
                mask_list.append(mask)

# 二、候选区域生成网络 #

候选区域生成网络（RPN）结构如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RlYXJfamluZw_size_16_color_FFFFFF_t_70]  
**大体工作流程为：** 针对一张特征图上的每个像素点，生成  k k k 个不同scale和ratio的锚框，然后将这些锚框堆叠成  256 − d 256-d 256−d 的向量，接下来针对每个锚框，RPN完成两项任务：

1.  **判断锚框中是否有目标**。仅需判定该锚框中是否含有需要检测的目标，因此进行简单的**二分类**（正样本或负样本），针对  k k k 个锚框生成  2 k 2k 2k 个分数
2.  **对锚框进行边界回归**。针对  k k k 个锚框产生  4 k 4k 4k 个坐标

之后，还需要进行一些后续操作：

*  将候选区域**映射回原图**，并剔除超出原图边界的候选区域；
 *  将“分数”从大到小进行**排序**，选出前2000个候选区域；
 *  采用 **NMS** 移除尺度过小以及所含目标相同的候选区域

最后，生成最终的候选区域。

--------------------

边界框回归（Bounding Box Regression）：  
在这个过程中，RPN生成的  4 k 4k 4k 个坐标**不是**预测边界框的坐标，**而是**变换参数（包括平移参数 d x dx dx， d y dy dy和伸缩参数 d w dw dw， d h dh dh）

“变换参数”是一种“映射关系”，能使得每个锚框通过这种映射关系都能够得到一个和真实边界框更接近的区域

详见：[【边框回归(Bounding Box Regression)详解】][Bounding Box Regression]

--------------------

# 2. build rpn
    # 生成候选框，并对候选框进行“二分类”fg / bg和“预测变换参数”
    with tf.variable_scope('build_rpn', regularizer=slim.l2_regularizer(cfgs.WEIGHT_DECAY)):
        fpn_cls_score = []
        fpn_box_pred = []
    
        for level_name, p in zip(cfgs.LEVLES, P_list):
            if cfgs.SHARE_HEADS:
                reuse_flag = None if level_name == cfgs.LEVLES[0] else True
                scope_list = ['rpn_conv/3x3', 'rpn_cls_score', 'rpn_bbox_pred']
            else:
                reuse_flag = None
                scope_list = ['rpn_conv/3x3_%s' % level_name, 'rpn_cls_score_%s' % level_name,
                              'rpn_bbox_pred_%s' % level_name]
    
            # 使用 3×3 卷积，调整输入图像 channel 为 512
            rpn_conv3x3 = slim.conv2d(p, 512, [3, 3],
                                      trainable=self.is_training, weights_initializer=cfgs.INITIALIZER,
                                      activation_fn=tf.nn.relu, padding="SAME",
                                      scope=scope_list[0],
                                      reuse=reuse_flag)
            # 计算分类概率，2k
            rpn_cls_score = slim.conv2d(rpn_conv3x3, self.num_anchors_per_location * 2, [1, 1], stride=1,
                                        trainable=self.is_training, weights_initializer=cfgs.INITIALIZER,
                                        activation_fn=None, padding="VALID",
                                        scope=scope_list[1],
                                        reuse=reuse_flag)
            # 预测边界框变换参数，4k
            rpn_box_pred = slim.conv2d(rpn_conv3x3, self.num_anchors_per_location * 4, [1, 1], stride=1,
                                       trainable=self.is_training, weights_initializer=cfgs.BBOX_INITIALIZER,
                                       activation_fn=None, padding="VALID",
                                       scope=scope_list[2],
                                       reuse=reuse_flag)
            rpn_cls_score = tf.reshape(rpn_cls_score, [-1, 2])
            rpn_box_pred = tf.reshape(rpn_box_pred, [-1, 4])
    
            fpn_cls_score.append(rpn_cls_score)
            fpn_box_pred.append(rpn_box_pred)
    
        fpn_cls_score = tf.concat(fpn_cls_score, axis=0, name='fpn_cls_score')
        # 用 softmax 进行二分类
        fpn_cls_prob = slim.softmax(fpn_cls_score, scope='fpn_cls_prob')
        fpn_box_pred = tf.concat(fpn_box_pred, axis=0, name='fpn_box_pred')

# 三、回归分类 #

def roi_pooling(self, feature_maps, rois, img_shape, scope):
        '''
        Here use roi warping as roi_pooling
    
        :param featuremaps_dict: feature map to crop
        :param rois: shape is [-1, 4]. [x1, y1, x2, y2]
        :return:
        '''
    
        with tf.variable_scope('ROI_Warping_' + scope):
            # -----------------1将 a set of RoIs 映射到 feature map 上---------------------
            # 确定 feature_maps 的大小
            img_h, img_w = tf.cast(img_shape[1], tf.float32), tf.cast(img_shape[2], tf.float32)
            # 确定 roi 的数量
            N = tf.shape(rois)[0]
            # 提取出每个 roi 的四个坐标，并分别存入 x1, y1, x2, y2
            x1, y1, x2, y2 = tf.unstack(rois, axis=1)
            # roi的坐标是针对原始图像的，在当前 img 上，scale 已经改变了，需要确定 roi 针对于当前 img 的坐标，即“归一化”
            normalized_x1 = x1 / img_w
            normalized_x2 = x2 / img_w
            normalized_y1 = y1 / img_h
            normalized_y2 = y2 / img_h
    
            # 将归一化的 x1, y1, x2, y2 坐标重新调整格式，以输入 tf.image.crop_and_resize 函数中
            normalized_rois = tf.transpose(
                tf.stack([normalized_y1, normalized_x1, normalized_y2, normalized_x2]), name='get_normalized_rois')
            # 停止反向传播？为什么要停止？
            normalized_rois = tf.stop_gradient(normalized_rois)
    
            # -----------------2将 h×w 的 rois crop成 H×W (cfgs.ROI_SIZE, cfgs.ROI_SIZE) 大小的小窗口---------------------
            # https://blog.csdn.net/m0_38024332/article/details/81779544
            cropped_roi_features = tf.image.crop_and_resize(feature_maps, normalized_rois,
                                                            box_ind=tf.zeros(shape=[N, ],
                                                                             dtype=tf.int32),
                                                            crop_size=[cfgs.ROI_SIZE, cfgs.ROI_SIZE],
                                                            name='CROP_AND_RESIZE')
            # -----------------3对每一个小窗口进行 max-pooling，将所有 roi 变成一样的大小---------------------
            roi_features = slim.max_pool2d(cropped_roi_features,
                                           [cfgs.ROI_POOL_KERNEL_SIZE, cfgs.ROI_POOL_KERNEL_SIZE],
                                           stride=cfgs.ROI_POOL_KERNEL_SIZE)
    
        return roi_features

[SCR Det_]: /images/20221022/c9e82c71554d48ef915f203eb607ee3c.png
[Faster R-CNN]: /images/20221022/73a787d78717404a841c55ff17baa987.png
[2021042409463818.png]: https://img-blog.csdnimg.cn/2021042409463818.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RlYXJfamluZw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210526205412728.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RlYXJfamluZw==,size_16,color_FFFFFF,t_70
[Bounding Box Regression]: https://blog.csdn.net/zijin0802034/article/details/77685438