【MaskRCNN】源码系列二：train&test特征图

最新推荐文章于 2023-04-15 17:05:54 发布
最新推荐文章于 2023-04-15 17:05:54 发布
阅读量1k 收藏 6
点赞数 3
分类专栏： 论文笔记 Keras
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013066730/article/details/102523638
版权

目录

Stage1

Stage2(C2)

conv_block

identity_block

Stage3(C3)

Stage4(C4)

Stage5(C5)

P5

P4

P3

P2

最终的P2、P3、P4、P5、P6

RPN和MRCNN使用特征图

特征图：是指通过CNN提取，被后续的RPN，RCNN使用的特征图。要求输入图像必须是64的倍数，具体原因请看下面的介绍。

从samples/coco/coco.py：

model = modellib.MaskRCNN(mode="training", config=config,
                          model_dir=args.logs)

到mrcnn/model.py：

    def __init__(self, mode, config, model_dir):
        """
        mode: Either "training" or "inference"
        config: A Sub-class of the Config class
        model_dir: Directory to save training logs and trained weights
        """
        assert mode in ['training', 'inference']
        self.mode = mode
        self.config = config
        self.model_dir = model_dir
        self.set_log_dir()
        self.keras_model = self.build(mode=mode, config=config)

再到mrcnn/model.py：

    def build(self, mode, config):

再到build函数中的模型建立模块

        if callable(config.BACKBONE):
            _, C2, C3, C4, C5 = config.BACKBONE(input_image, stage5=True,
                                                train_bn=config.TRAIN_BN)
        else:
            _, C2, C3, C4, C5 = resnet_graph(input_image, config.BACKBONE,
                                             stage5=True, train_bn=config.TRAIN_BN)

config.BACKBONE=‘resnet101’，但是没有这个函数，只有resnet_graph这个函数，这里我不知道作者想表达什么意思，不管了。

正式进入到我们的模型构建了：

def resnet_graph(input_image, architecture, stage5=False, train_bn=True):

输入参数

input_image：（batchsize，1024，1024，3）

architecture：resnet101

stage5：True

train_bn：False，这里设置为False，后面在训练的时候会重新设置。

 

接下来我们看看到底有哪几个步骤

Stage1

    # Stage 1
    x = KL.ZeroPadding2D((3, 3))(input_image)
    x = KL.Conv2D(64, (7, 7), strides=(2, 2), name='conv1', use_bias=True)(x)
    x = BatchNorm(name='bn_conv1')(x, training=train_bn)
    x = KL.Activation('relu')(x)
    C1 = x = KL.MaxPooling2D((3, 3), strides=(2, 2), padding="same")(x)

第一个？表示batchsize，特征图+通道数。stage1得到的结果为(?,256,256,64)

Stage2(C2)

    # Stage 2
    x = conv_block(x, 3, [64, 64, 256], stage=2, block='a', strides=(1, 1), train_bn=train_bn)
    x = identity_block(x, 3, [64, 64, 256], stage=2, block='b', train_bn=train_bn)
    C2 = x = identity_block(x, 3, [64, 64, 256], stage=2, block='c', train_bn=train_bn)

上面这段代码包含了conv_block，identity_block，这里就先看看这2个函数到底干了什么事情。

conv_block

def conv_block(input_tensor, kernel_size, filters, stage, block,
               strides=(2, 2), use_bias=True, train_bn=True):
    """conv_block is the block that has a conv layer at shortcut
    # Arguments
        input_tensor: input tensor
        kernel_size: default 3, the kernel size of middle conv layer at main path
        filters: list of integers, the nb_filters of 3 conv layer at main path
        stage: integer, current stage label, used for generating layer names
        block: 'a','b'..., current block label, used for generating layer names
        use_bias: Boolean. To use or not use a bias in conv layers.
        train_bn: Boolean. Train or freeze Batch Norm layers
    Note that from stage 3, the first conv layer at main path is with subsample=(2,2)
    And the shortcut should have subsample=(2,2) as well
    """
    nb_filter1, nb_filter2, nb_filter3 = filters
    conv_name_base = 'res' + str(stage) + block + '_branch'
    bn_name_base = 'bn' + str(stage) + block + '_branch'

    x = KL.Conv2D(nb_filter1, (1, 1), strides=strides,
                  name=conv_name_base + '2a', use_bias=use_bias)(input_tensor)
    x = BatchNorm(name=bn_name_base + '2a')(x, training=train_bn)
    x = KL.Activation('relu')(x)

    x = KL.Conv2D(nb_filter2, (kernel_size, kernel_size), padding='same',
                  name=conv_name_base + '2b', use_bias=use_bias)(x)
    x = BatchNorm(name=bn_name_base + '2b')(x, training=train_bn)
    x = KL.Activation('relu')(x)

    x = KL.Conv2D(nb_filter3, (1, 1), name=conv_name_base +
                  '2c', use_bias=use_bias)(x)
    x = BatchNorm(name=bn_name_base + '2c')(x, training=train_bn)

    shortcut = KL.Conv2D(nb_filter3, (1, 1), strides=strides,
                         name=conv_name_base + '1', use_bias=use_bias)(input_tensor)
    shortcut = BatchNorm(name=bn_name_base + '1')(shortcut, training=train_bn)

    x = KL.Add()([x, shortcut])
    x = KL.Activation('relu', name='res' + str(stage) + block + '_out')(x)
    return x

输入参数：

input_tensor：具体以实际情况而定，这里是（?,256,256,64）

kernel_size：3

filters：[64,64,256]

stage：2

block：'a'

strides：(1, 1)或者（2，2），这里以（1，1）举例

use_bias：True

train_bn：False

最终返回结果为（?,256,256,256）。 

identity_block

def identity_block(input_tensor, kernel_size, filters, stage, block,
                   use_bias=True, train_bn=True):
    """The identity_block is the block that has no conv layer at shortcut
    # Arguments
        input_tensor: input tensor
        kernel_size: default 3, the kernel size of middle conv layer at main path
        filters: list of integers, the nb_filters of 3 conv layer at main path
        stage: integer, current stage label, used for generating layer names
        block: 'a','b'..., current block label, used for generating layer names
        use_bias: Boolean. To use or not use a bias in conv layers.
        train_bn: Boolean. Train or freeze Batch Norm layers
    """
    nb_filter1, nb_filter2, nb_filter3 = filters
    conv_name_base = 'res' + str(stage) + block + '_branch'
    bn_name_base = 'bn' + str(stage) + block + '_branch'

    x = KL.Conv2D(nb_filter1, (1, 1), name=conv_name_base + '2a',
                  use_bias=use_bias)(input_tensor)
    x = BatchNorm(name=bn_name_base + '2a')(x, training=train_bn)
    x = KL.Activation('relu')(x)

    x = KL.Conv2D(nb_filter2, (kernel_size, kernel_size), padding='same',
                  name=conv_name_base + '2b', use_bias=use_bias)(x)
    x = BatchNorm(name=bn_name_base + '2b')(x, training=train_bn)
    x = KL.Activation('relu')(x)

    x = KL.Conv2D(nb_filter3, (1, 1), name=conv_name_base + '2c',
                  use_bias=use_bias)(x)
    x = BatchNorm(name=bn_name_base + '2c')(x, training=train_bn)

    x = KL.Add()([x, input_tensor])
    x = KL.Activation('relu', name='res' + str(stage) + block + '_out')(x)
    return x

输入参数：

input_tensor：具体以实际情况而定，这里是（?,256,256,256）

kernel_size：3

filters：[64,64,256]

stage：2

block：'b'

use_bias：True

train_bn：False

 该函数返回的形状为(?,256,256,256)。

这里stage2进行了conv_block，identity_block，identity_block。

 stageblockkernel_sizestridefilters输入尺寸输出尺寸
conv_block2'a'31[64,64,256]（？，256，256，64）（？，256，256，256）
identity_block2'b'31[64,64,256]（？，256，256，256）（？，256，256，256）
identity_block2'c'31[64,64,256]（？，256，256，256）（？，256，256，256）

最终x和C2的输出形状都为(?,256,256,256)。

Stage3(C3)

    # Stage 3
    x = conv_block(x, 3, [128, 128, 512], stage=3, block='a', train_bn=train_bn)
    x = identity_block(x, 3, [128, 128, 512], stage=3, block='b', train_bn=train_bn)
    x = identity_block(x, 3, [128, 128, 512], stage=3, block='c', train_bn=train_bn)
    C3 = x = identity_block(x, 3, [128, 128, 512], stage=3, block='d', train_bn=train_bn)

共进行了conv_block、identity_block、identity_block、identity_block。

 stageblockkernel_sizestridefilters输入尺寸输出尺寸
conv_block3'a'32[128,128,512]（？，256，256，256）（？，128，128，512）
identity_block3'b'31[128,128,512]（？，128，128，512）（？，128，128，512）
identity_block3'c'31[128,128,512]（？，128，128，512）（？，128，128，512）
identity_block3'd'31[128,128,512]（？，128，128，512）（？，128，128，512）

 最终x和C3的输出形状都为(?,128,128,512)。

Stage4(C4)

    # Stage 4
    x = conv_block(x, 3, [256, 256, 1024], stage=4, block='a', train_bn=train_bn)
    block_count = {"resnet50": 5, "resnet101": 22}[architecture]
    for i in range(block_count):
        x = identity_block(x, 3, [256, 256, 1024], stage=4, block=chr(98 + i), train_bn=train_bn)
    C4 = x
 stageblockkernel_sizestridefilters输入尺寸输出尺寸
conv_block4'a'32[256,256,1024]（？，128，128，512）（？，64，64，1024）
identity_block(重复22次，i就表示第几次)498+i31[256,256,1024]（？，64，64，1024）（？，64，64，1024）

 最终x和C4的输出形状为(?,64,64,1024)。

Stage5(C5)

        x = conv_block(x, 3, [512, 512, 2048], stage=5, block='a', train_bn=train_bn)
        x = identity_block(x, 3, [512, 512, 2048], stage=5, block='b', train_bn=train_bn)
        C5 = x = identity_block(x, 3, [512, 512, 2048], stage=5, block='c', train_bn=train_bn)
 stageblockkernel_sizestridefilters输入尺寸输出尺寸
conv_block5'a'32[512,512,2048]（？，64，64，1024）（？，32，32，2048）
identity_block5'b'31[512,512,2048]（？，32，32，2048）（？，32，32，2048）
identity_block5'c'31[512,512,2048]（？，32，32，2048）（？，32，32，2048）

 最终的x和C5的输出形状为(?,32,32,2048)。

return [C1, C2, C3, C4, C5]返回C1,C2,C3,C4,C5的列表。

P5

        P5 = KL.Conv2D(config.TOP_DOWN_PYRAMID_SIZE, (1, 1), name='fpn_c5p5')(C5)

由于C5的形状为（？，32，32，2048），要求输出的通道数为256，所以P5的形状为（？，32，32，256）。

P4

        P4 = KL.Add(name="fpn_p4add")([
            KL.UpSampling2D(size=(2, 2), name="fpn_p5upsampled")(P5),
            KL.Conv2D(config.TOP_DOWN_PYRAMID_SIZE, (1, 1), name='fpn_c4p4')(C4)])

P5进行2倍的上采样，其形状变为（？，64，64，256）。C4经过1*1的卷积变换通道数量，其形状为（？，64，64，256）。再将这2个变换过的张量进行求和，得到P4，其形状为（？，64，64，256）。

P3

        P3 = KL.Add(name="fpn_p3add")([
            KL.UpSampling2D(size=(2, 2), name="fpn_p4upsampled")(P4),
            KL.Conv2D(config.TOP_DOWN_PYRAMID_SIZE, (1, 1), name='fpn_c3p3')(C3)])

将P4进行2倍的上采样，其形状变为（？，128，128，256）。C3经过1*1的卷积变换通道数量，其形状为（？，128，128，256）。再将这2个变换过的张量进行求和，得到P3，其形状为（？，128，128，256）。

P2

        P2 = KL.Add(name="fpn_p2add")([
            KL.UpSampling2D(size=(2, 2), name="fpn_p3upsampled")(P3),
            KL.Conv2D(config.TOP_DOWN_PYRAMID_SIZE, (1, 1), name='fpn_c2p2')(C2)])

将P3进行2倍的上采样，其形状变为（？，256，256，256）。C2经过1*1的卷积变换通道数量，其形状为（？，256，256，256）。再将这2个变换过的张量进行求和，得到P2，其形状为（？，256，256，256）。

最终的P2、P3、P4、P5、P6

        # Attach 3x3 conv to all P layers to get the final feature maps.
        P2 = KL.Conv2D(config.TOP_DOWN_PYRAMID_SIZE, (3, 3), padding="SAME", name="fpn_p2")(P2)
        P3 = KL.Conv2D(config.TOP_DOWN_PYRAMID_SIZE, (3, 3), padding="SAME", name="fpn_p3")(P3)
        P4 = KL.Conv2D(config.TOP_DOWN_PYRAMID_SIZE, (3, 3), padding="SAME", name="fpn_p4")(P4)
        P5 = KL.Conv2D(config.TOP_DOWN_PYRAMID_SIZE, (3, 3), padding="SAME", name="fpn_p5")(P5)
        # P6 is used for the 5th anchor scale in RPN. Generated by
        # subsampling from P5 with stride of 2.
        P6 = KL.MaxPooling2D(pool_size=(1, 1), strides=2, name="fpn_p6")(P5)

P2、P3、P4、P5都是经过一个（3，3）的卷积，大小不变，特征进行再提取。P6是对P5进行的一次下采样，得到的形状为（？，16，16，256）。

所以图像必须是1024/16=64的倍数。

RPN和MRCNN使用特征图

        # Note that P6 is used in RPN, but not in the classifier heads.
        rpn_feature_maps = [P2, P3, P4, P5, P6]
        mrcnn_feature_maps = [P2, P3, P4, P5]

可以看出rpn使用p2到p6，而mrcnn只使用了p2到p5。

我认为是为了rpn多选一点框出来，防止某些目标被漏了。另外mrcnn不用主要是由于有mask的分割，你特征图太小了，分割的也不会很准。

最终这些特征图的形状为：

P2(1,256,256,256)
P3(1,128,128,256)
P4(1,64,64,256)
P5(1,32,32,256)
P6(1,16,16,256)

 

mjiansun
关注
专栏目录
Mask-RCNN(2) : 代码使用
@bangbang的博客
02-12 1620
当一个batch的长宽比率相差比较大的时候，我们真正输入网络的图片其实是很大的。，如果在验证的时候单张输入图片的话，那么我们输入网络的图片大小其实是和当前图片大小是一样的，此时我们对图片不需要太多处理。每隔10个epoch进行验证, 不过这样就没法获得保存每个epoch的验证结果，这样就没法根据每个epoch它的验证结果去绘制对应的曲线了。所以按照长宽比率进行排序之后，我们对它分组，然后再组内进行采样，这样我们输入网络的图片打包成batch它的大小会更小些，从而对。的，在目标检测中是没有使用到的。
【纯小白】动手实现MASK RCNN 实例分割（带全部源码）
m0_51325463的博客
10-25 8021
本文档依据Pytorch官方，CSDN，哔哩哔哩，Github多方总结改变实现，如有侵权，联系速删！！此文档旨在帮助小白使用pytorch一步步实现Mask Rcnn 网络。后续将会推出如何使用此网络训练自己的数据集。如在搭建过程中出现种种错误，欢迎骚扰我，我会尽力解决。
Mask rcnn训练集（自制）
12-18
资源为本人工作时使用到的数据 包括四个文件夹cv2_mask、json、labelme_json和pic 可以直接应用于mask rcnn 源码，这里不做多余的解释 由于上传限制，只上传了部分样本 如果想交流学习心得或不明白的位置，可以私信我。
MaskRCNN源码解析2：特征图与anchors生成
01-01 6235
MaskRCNN源码解析1：整体结构概述 MaskRCNN源码解析2：特征图与anchors生成 MaskRCNN源码解析3：RPN、ProposalLayer、DetectionTargetLayer MaskRCNN源码解析4-0：ROI Pooling 与 ROI Align理论 MaskRCNN源码解析4：头网络(Networks Heads)解析 MaskRCNN源码解析5：损...
训练DPT:由测试test到训练train图像的一个epochs的optimize.zero_grad() loss.backward() optimizer.step()
MengYa_Dream的博客
03-09 2189
训练DPT 如何从test进一步得到train呢？一个epochs的optimize.zero_grad() loss.backward() optimizer.step()
学习mask rcnn，day4（fpn层与特征提取框）
huhu1456的博客
03-23 216
【代码】学习mask rcnn，day4。
Mask RCNN 源代码解析 (1) - 整体思路
hnshahao的专栏
07-27 2万+
Mask RCNN 属于 RCNN这一系列的应该是比较最终的版本，融合多种算法的思想，这里对Mask RCNN从源代码进行解析，主要写几篇文章，一个总结大的思路，其他文章整理细节。 这篇文章为了简单，主要从前向传播和后向传播，分两部分进行介绍，主要以数据的流动为主线，分析流程图和核心函数。主要参考的代码是Pytorch的mask RCNN版本， 这个版本的Mask RCNN代码只支持一个图片处理...
maskrcnn benchmark pytorch 训练+测试
weixin_43716602的博客
09-11 1619
项目网址：maskrcnn benchmark 系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录系列文章目录前言一、环境搭建1.准备工作出现的问题1解决方案1：二、数据集准备1.labelme2coco2.更改配置文件三、训练测试总结 前言 文章主要记录在windows下和linux下使用maskrcnn进行环境搭建 训练 测试 的过
Maskrcnn-benchmark利用自己的数据进行目标检测和关键点检测
ylq0505的博客
10-26 5501
Maskrcnn-benchmark利用自己的数据进行目标检测和关键点检测介绍0 环境配置RequirementsInstallation1 目标检测任务1.1 数据准备1.1.1 coco数据集的介绍1.1.2 转coco数据1.1.3 数据检验1.2 数据集在源代码文件中的组织结构1.3 使用预训练模型1.4 源码文件的修改1.5 模型训练1.6 模型验证1.7 前传1.8 几个常见的问题2 ...
tensorflow:使用mask-RCNN训练自己的数据集
m0_49100031的博客
08-09 1343
一：所需环境 numpy scipy Pillow cython matplotlib scikit-image tensorflow>=1.3.0 keras>=2.0.8 opencv-python h5py imgaug IPython[all] 快速安装tensorflow-gpu链接： https://blog.csdn.net/m0_49100031/article/details/119534426?spm=1001.2014.3001.5502 二：准备数据 labelme数据标
一文读懂Mask-RCNN笔记（全）
11-20
Mask-RCNN提出了一个实例分割的框架，可以在有效地检测图像中目标的同时为每一个实例产生一个高质量分割Mask。 Mask-RCNN扩展了Faster R-CNN，通过在之前已存在的边界框回归分支上添加新的一个预测目标Mask的分支。
Mask rcnn训练、测试自己的数据集（多目标检测）
YL950305的博客
11-06 5910
文章目录前言1. 数据集制作1.1 数据集准备1.1.1 样本1.1.2 rename.py 重命名1.1.3 resize.cpp 统一图片的尺寸1.1 labelme标记得到json文件1.2 json_to_dataset.py将json文件转为label.png1.3 get_png.py 提取label.png1.4 制作mask rcnn数据集2. 代码修改2.1 训练文件train.py2.2 train.py修改的部分2.3 测试文件fortest.py2.4 fortest.py修改总结
使用Mask-RCNN训练自己的数据集看这一篇就够了，从制作数据集开始一步步教你如何玩转Mask-RCNN（保姆级教程）
ekekex的博客
04-15 1万+
使用Mask_RCNN训练自己的数据集的方法，教你从零开始训练自己的Mask_RCNN模型。
maskRcnn训练自己的数据集
weixin_43694742的博客
03-06 1286
、
180724 图解MaskRCNN模型代码(待更新)
专注机器学习之路
07-24 6570
本文内容：主要针对目前Github上的matterport/Mask_RCNN代码进行解读,该代码多达2875行, 对代码进行解读,有利于对文章及原理有进一步的理解. 参考文献 ResNet及mask_rcnn中使用的ResNet网络结构 -【mask_rcnn】 ResNet50 结构 Andrew Ng deeplearning courese-4:Convolutional Neura...
Mask RCNN －原理解析（一）
热门推荐
ghw15221836342的博客
04-25 3万+
Mask RCNN 原理：简单说一下Mask R-CNN 是一个两阶段的框架，第一个阶段扫描图像并生成提议（proposals，即有可能包含一个目标的区域），第二阶段分类提议并生成边界框和掩码。Mask R-CNN 扩展自 Faster R-CNN，由同一作者在去年提出。Faster R-CNN 是一个流行的目标检测框架，Mask R-CNN 将其扩展为实例分割框架。Mask R-CNN 的主要构...
tensorflow关于bn层使用问题,特别是train参数的设置问题
so
07-28 2033
描述坑的过程: resnet50做分类,使用了bn层 在训练的时候用了一个is_train占位符来区分训练和测试(单独区分开的,并不是一起做的) 训练的时候is_train=True,测试的时候is_train=False 现象:训练精度很高,测试精度不忍直视 问题原因: 这个可能是因为没有把bn层里面的训练时统计出的参数保持下来造成的，在保存模型的时候，除了保存weights,bia...
2019.12.11 对于keras框架BN层的一些tips
馨宇要变身的博客
12-11 6385
2019.12.111.Keras中Batchnormalization层到底怎么用？2.BN层的作用3.BN的解释4.BatchNormalization Layer中momentum参数的意义5.我的个人总结 1.Keras中Batchnormalization层到底怎么用？ 看了七七八八的博客，没有统一的说法。 列举一些： A. BN层是真的吊，简直神器，除了会使网络搭建的时间和每个epoc...
【MaskRCNN】源码系列五：train的MASK
mjiansun的专栏
10-23 1128
mrcnn_mask = build_fpn_mask_graph(rois, mrcnn_feature_maps, input_image_meta, config.MASK_POOL_...
mask rcnn源码解析
最新发布
05-27
Mask R-CNN 是一种用于图像分割的深度学习模型，是 Faster R-CNN 的扩展版本。下面是 Mask R-CNN 的源码解析： 1. 数据加载和预处理 在 Mask R-CNN 的源码中，数据加载和预处理是通过继承 PyTorch 中的 Dataset 和 DataLoader 实现的。在加载数据时，会对图像进行裁剪、缩放和归一化等预处理操作。 2. 网络结构 Mask R-CNN 网络结构主要是基于 Faster R-CNN，将 Faster R-CNN 的 RPN 网络和 RoI Pooling 网络替换成了 RPN 网络和 RoI Align 网络。RoI Align 网络可以更精确的对 RoI 区域进行划分，从而提高了模型的分割精度。 3. 损失函数 Mask R-CNN 的损失函数主要包括分类损失、回归损失和掩膜分割损失。分类损失和回归损失与 Faster R-CNN 相同，掩膜分割损失是基于交叉熵损失函数和二进制交叉熵损失函数实现的。 4. 训练和测试 在训练过程中，Mask R-CNN 采用了分阶段训练的策略，即首先训练 RPN 网络，然后训练 Faster R-CNN 网络，最后训练掩膜分割网络。在测试过程中，Mask R-CNN 通过对 RoI 区域应用掩膜分割网络，生成掩膜分割结果。 以上就是 Mask R-CNN 的源码解析，通过对源码的分析，可以更好地理解 Mask R-CNN 的原理和实现方式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值