mask_rcnn keras源码跟读1）模型搭建

基础知识：faster_rcnn相关内容，mask_rcnn相关内容
源码git:https://github.com/matterport/Mask_RCNN/tree/v2.1

1.模型搭建
主要在类MaskRCNN的build方法内（model.py_1822行）

1.1基础网络_resnet101网络

  # Build the shared convolutional layers.# Bottom-up Layers# Returns a list of the last layers of each stage, 5 in total.# Don't create the thead (stage 5), so we pick the 4th item in the list._, C2, C3, C4, C5 = resnet_graph(input_image, config.BACKBONE,stage5=True, train_bn=config.TRAIN_BN)

resnet_graph就是标准的resnet网络，如图1所示C1，C2和layer_name对应，这里没有用C1(stage 5)，C2, C3, C4, C5用于FPN网络

resnet相关介绍：https://blog.csdn.net/jiangpeng59/article/details/79609392

1.2 特征提取网络_FPN网络
简单介绍FPN：把底层的特征和高层的特征进行融合，便于细致检测。这里P5=C5，然后P4=P5+C4,最终得到rpn_feature_maps，注意这里多了个P6,其仅是由P5下采样获得。
FPN网络相关：https://blog.csdn.net/u014380165/article/details/72890275

# Top-down Layers
# TODO: add assert to varify feature map sizes match what's in config
P5 = KL.Conv2D(256, (1, 1), name='fpn_c5p5')(C5)
P4 = KL.Add(name="fpn_p4add")([KL.UpSampling2D(size=(2, 2), name="fpn_p5upsampled")(P5),KL.Conv2D(256, (1, 1), name='fpn_c4p4')(C4)])
P3 = KL.Add(name="fpn_p3add")([KL.UpSampling2D(size=(2, 2), name="fpn_p4upsampled")(P4),KL.Conv2D(256, (1, 1), name='fpn_c3p3')(C3)])
P2 = KL.Add(name="fpn_p2add")([KL.UpSampling2D(size=(2, 2), name="fpn_p3upsampled")(P3),KL.Conv2D(256, (1, 1), name='fpn_c2p2')(C2)])
# Attach 3x3 conv to all P layers to get the final feature maps.
P2 = KL.Conv2D(256, (3, 3), padding="SAME", name="fpn_p2")(P2)
P3 = KL.Conv2D(256, (3, 3), padding="SAME", name="fpn_p3")(P3)
P4 = KL.Conv2D(256, (3, 3), padding="SAME", name="fpn_p4")(P4)
P5 = KL.Conv2D(256, (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)# 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]

1.3 RPN网络
RPN主要实现2个功能：
1> box的前景色和背景色的分类
2>box框体的回归修正

# RPN Model
rpn = build_rpn_model(config.RPN_ANCHOR_STRIDE,len(config.RPN_ANCHOR_RATIOS), 256)

然后进入到build_rpn_model函数，其把rpn定义成模型，便于重复使用

def build_rpn_model(anchor_stride, anchors_per_location, depth):"""Builds a Keras model of the Region Proposal Network.It wraps the RPN graph so it can be used multiple times with sharedweights.anchors_per_location: number of anchors per pixel in the feature mapanchor_stride: Controls the density of anchors. Typically 1 (anchors forevery pixel in the feature map), or 2 (every other pixel).depth: Depth of the backbone feature map.Returns a Keras Model object. The model outputs, when called, are:rpn_logits: [batch, H, W, 2] Anchor classifier logits (before softmax)rpn_probs: [batch, W, W, 2] Anchor classifier probabilities.rpn_bbox: [batch, H, W, (dy, dx, log(dh), log(dw))] Deltas to beapplied to anchors."""input_feature_map = KL.Input(shape=[None, None, depth],name="input_rpn_feature_map")outputs = rpn_graph(input_feature_map, anchors_per_location, anchor_stride)return KM.Model([input_feature_map], outputs, name="rpn_model")

主要看rpn_graph函数，首先对FPN传递过来的feature_map进行一个3*3的卷积(增强鲁棒性?)，然后对这个输出的共享feature_map进行了2个分支：（1）前景和背景的分类 （2）框体坐标回归
以背景/前景分类为例，shared的feature_map中每个像素点都有anchors_per_location个anchor， 而每个anchor都有2个概率的取值(BG/FG)，reshape后即可获得所有anchor对应BG/FG的取值。

def rpn_graph(feature_map, anchors_per_location, anchor_stride):"""Builds the computation graph of Region Proposal Network.feature_map: backbone features [batch, height, width, depth]anchors_per_location: number of anchors per pixel in the feature mapanchor_stride: Controls the density of anchors. Typically 1 (anchors forevery pixel in the feature map), or 2 (every other pixel).Returns:rpn_logits: [batch, H, W, 2] Anchor classifier logits (before softmax)rpn_probs: [batch, H, W, 2] Anchor classifier probabilities.rpn_bbox: [batch, H, W, (dy, dx, log(dh), log(dw))] Deltas to beapplied to anchors."""# TODO: check if stride of 2 causes alignment issues if the featuremap#       is not even.# Shared convolutional base of the RPNshared = KL.Conv2D(512, (3, 3), padding='same', activation='relu',strides=anchor_stride,name='rpn_conv_shared')(feature_map)# Anchor Score. [batch, height, width, anchors per location * 2].x = KL.Conv2D(2 * anchors_per_location, (1, 1), padding='valid',activation='linear', name='rpn_class_raw')(shared)# Reshape to [batch, anchors, 2]rpn_class_logits = KL.Lambda(lambda t: tf.reshape(t, [tf.shape(t)[0], -1, 2]))(x)# Softmax on last dimension of BG/FG.rpn_probs = KL.Activation("softmax", name="rpn_class_xxx")(rpn_class_logits)# Bounding box refinement. [batch, H, W, anchors per location, depth]# where depth is [x, y, log(w), log(h)]x = KL.Conv2D(anchors_per_location * 4, (1, 1), padding="valid",activation='linear', name='rpn_bbox_pred')(shared)# Reshape to [batch, anchors, 4]rpn_bbox = KL.Lambda(lambda t: tf.reshape(t, [tf.shape(t)[0], -1, 4]))(x)return [rpn_class_logits, rpn_probs, rpn_bbox]

然后让FPN网络生成的 rpn_feature_maps = [P2, P3, P4, P5, P6]，依次通过RPN网络，获得对应的输出[“rpn_class_logits”, “rpn_class”, “rpn_bbox”]，并把对应的结果有序地整合在一起

# Loop through pyramid layers
layer_outputs = []  # list of lists
for p in rpn_feature_maps:layer_outputs.append(rpn([p]))
# Concatenate layer outputs
# Convert from list of lists of level outputs to list of lists
# of outputs across levels.
# e.g. [[a1, b1, c1], [a2, b2, c2]] => [[a1, a2], [b1, b2], [c1, c2]]
output_names = ["rpn_class_logits", "rpn_class", "rpn_bbox"]
outputs = list(zip(*layer_outputs))
outputs = [KL.Concatenate(axis=1, name=n)(list(o))for o, n in zip(outputs, output_names)]rpn_class_logits, rpn_class, rpn_bbox = outputs

1.4 ProposalLayer 层
proposals简介：筛选后的anchor（拥有更多目标前景，anchor更加接近target_box）
生成的proposal并非越多越好，因而设置了阈值proposal_count ，关于非极大值抑制NMS，可以参考：非极大值抑制的几种实现

# Generate proposals
# Proposals are [batch, N, (y1, x1, y2, x2)] in normalized coordinates
# and zero padded.
proposal_count = config.POST_NMS_ROIS_TRAINING if mode == "training"\else config.POST_NMS_ROIS_INFERENCE
rpn_rois = ProposalLayer(proposal_count=proposal_count,nms_threshold=config.RPN_NMS_THRESHOLD,name="ROI",config=config)([rpn_class, rpn_bbox, anchors])

然后进入到自定义的层ProposalLayer，其接受的参数有3个：
rpn_probs：所有像素点BG/FG的概率值。
rpn_bbox：所有像素点对应anchor上的4个偏移值*[dy, dx, log(dh), log(dw)]*。
anchors:预先生成的有序anchor列表，注意这里有序表示feature_map上像素点生成的anchor以及该像素点生成的rpn_probs和rpn_bbox是对应的（这样理解对?）。
最终ProposalLayer会返回一个边框修正后及mns过滤的anchor集合(称为roi或proposal)，至此已经完成了目标的检测

class ProposalLayer(KE.Layer):"""Receives anchor scores and selects a subset to pass as proposalsto the second stage. Filtering is done based on anchor scores andnon-max suppression to remove overlaps. It also applies boundingbox refinement deltas to anchors.Inputs:rpn_probs: [batch, anchors, (bg prob, fg prob)]rpn_bbox: [batch, anchors, (dy, dx, log(dh), log(dw))]anchors: [batch, (y1, x1, y2, x2)] anchors in normalized coordinatesReturns:Proposals in normalized coordinates [batch, rois, (y1, x1, y2, x2)]"""def __init__(self, proposal_count, nms_threshold, config=None, **kwargs):super(ProposalLayer, self).__init__(**kwargs)self.config = configself.proposal_count = proposal_countself.nms_threshold = nms_thresholddef call(self, inputs):# Box Scores. Use the foreground class confidence. [Batch, num_rois, 1]scores = inputs[0][:, :, 1]# Box deltas [batch, num_rois, 4]deltas = inputs[1]deltas = deltas * np.reshape(self.config.RPN_BBOX_STD_DEV, [1, 1, 4])# Anchorsanchors = inputs[2]# Improve performance by trimming to top anchors by score# and doing the rest on the smaller subset.pre_nms_limit = tf.minimum(6000, tf.shape(anchors)[1])ix = tf.nn.top_k(scores, pre_nms_limit, sorted=True,name="top_anchors").indicesscores = utils.batch_slice([scores, ix], lambda x, y: tf.gather(x, y),self.config.IMAGES_PER_GPU)deltas = utils.batch_slice([deltas, ix], lambda x, y: tf.gather(x, y),self.config.IMAGES_PER_GPU)pre_nms_anchors = utils.batch_slice([anchors, ix], lambda a, x: tf.gather(a, x),self.config.IMAGES_PER_GPU,names=["pre_nms_anchors"])# Apply deltas to anchors to get refined anchors.# [batch, N, (y1, x1, y2, x2)]boxes = utils.batch_slice([pre_nms_anchors, deltas],lambda x, y: apply_box_deltas_graph(x, y),self.config.IMAGES_PER_GPU,names=["refined_anchors"])#normalized coordinates就是对应原图的百分比坐标#下面的作用：防止修正后的anchor坐标超出了边界即0<=x,y<=1# Clip to image boundaries. Since we're in normalized coordinates,# clip to 0..1 range. [batch, N, (y1, x1, y2, x2)]window = np.array([0, 0, 1, 1], dtype=np.float32)boxes = utils.batch_slice(boxes,lambda x: clip_boxes_graph(x, window),self.config.IMAGES_PER_GPU,names=["refined_anchors_clipped"])# Filter out small boxes# According to Xinlei Chen's paper, this reduces detection accuracy# for small objects, so we're skipping it.# Non-max suppressiondef nms(boxes, scores):indices = tf.image.non_max_suppression(boxes, scores, self.proposal_count,self.nms_threshold, name="rpn_non_max_suppression")proposals = tf.gather(boxes, indices)# Pad if neededpadding = tf.maximum(self.proposal_count - tf.shape(proposals)[0], 0)#不足阈值大小则底部补0来填充proposals = tf.pad(proposals, [(0, padding), (0, 0)])return proposalsproposals = utils.batch_slice([boxes, scores], nms,self.config.IMAGES_PER_GPU)return proposalsdef compute_output_shape(self, input_shape):return (None, self.proposal_count, 4)

1.5DetectionTargetLayer层

# Generate detection targets
# Subsamples proposals and generates target outputs for training
# Note that proposal class IDs, gt_boxes, and gt_masks are zero
# padded. Equally, returned rois and targets are zero padded.
#target_rois即上面proposal_layer的rpn_rois输出(通常会用rpn网络)
rois, target_class_ids, target_bbox, target_mask =\DetectionTargetLayer(config, name="proposal_targets")([target_rois, input_gt_class_ids, gt_boxes, input_gt_masks])

在其类中，主要关注call部分

class DetectionTargetLayer(KE.Layer):"""Subsamples proposals and generates target box refinement, class_ids,and masks for each.Inputs:proposals: [batch, N, (y1, x1, y2, x2)] in normalized coordinates. Mightbe zero padded if there are not enough proposals.gt_class_ids: [batch, MAX_GT_INSTANCES] Integer class IDs.gt_boxes: [batch, MAX_GT_INSTANCES, (y1, x1, y2, x2)] in normalizedcoordinates.gt_masks: [batch, height, width, MAX_GT_INSTANCES] of boolean typeReturns: Target ROIs and corresponding class IDs, bounding box shifts,and masks.rois: [batch, TRAIN_ROIS_PER_IMAGE, (y1, x1, y2, x2)] in normalizedcoordinatestarget_class_ids: [batch, TRAIN_ROIS_PER_IMAGE]. Integer class IDs.target_deltas: [batch, TRAIN_ROIS_PER_IMAGE, NUM_CLASSES,(dy, dx, log(dh), log(dw), class_id)]Class-specific bbox refinements.target_mask: [batch, TRAIN_ROIS_PER_IMAGE, height, width)Masks cropped to bbox boundaries and resized to neuralnetwork output size.Note: Returned arrays might be zero padded if not enough target ROIs."""def call(self, inputs):proposals = inputs[0]gt_class_ids = inputs[1]gt_boxes = inputs[2]gt_masks = inputs[3]# Slice the batch and run a graph for each slice# TODO: Rename target_bbox to target_deltas for claritynames = ["rois", "target_class_ids", "target_bbox", "target_mask"]outputs = utils.batch_slice([proposals, gt_class_ids, gt_boxes, gt_masks],lambda w, x, y, z: detection_targets_graph(w, x, y, z, self.config),self.config.IMAGES_PER_GPU, names=names)return outputs

detection_targets_graph函数负责处理输入的[proposals, gt_class_ids, gt_boxes, gt_masks]
代码有点长，首先计算proposals和gt_boxes的覆盖度矩阵proposals*gt_boxes，然后获得每个proposals一个与gt_boxes最大覆盖度值roi_iou_max，如果roi_iou_max>0.5，则认为该proposals是 positive_roi，最后再把对应gt_box分配给对应的positive_roi并进行框体微调获得对应偏移。最终返回的rois包含positive_roi和negative_roi。

def detection_targets_graph(proposals, gt_class_ids, gt_boxes, gt_masks, config):"""Generates detection targets for one image. Subsamples proposals andgenerates target class IDs, bounding box deltas, and masks for each.Inputs:proposals: [N, (y1, x1, y2, x2)] in normalized coordinates. Mightbe zero padded if there are not enough proposals.gt_class_ids: [MAX_GT_INSTANCES] int class IDsgt_boxes: [MAX_GT_INSTANCES, (y1, x1, y2, x2)] in normalized coordinates.gt_masks: [height, width, MAX_GT_INSTANCES] of boolean type.Returns: Target ROIs and corresponding class IDs, bounding box shifts,and masks.rois: [TRAIN_ROIS_PER_IMAGE, (y1, x1, y2, x2)] in normalized coordinatesclass_ids: [TRAIN_ROIS_PER_IMAGE]. Integer class IDs. Zero padded.deltas: [TRAIN_ROIS_PER_IMAGE, NUM_CLASSES, (dy, dx, log(dh), log(dw))]Class-specific bbox refinements.masks: [TRAIN_ROIS_PER_IMAGE, height, width). Masks cropped to bboxboundaries and resized to neural network output size.Note: Returned arrays might be zero padded if not enough target ROIs."""# Assertionsasserts = [tf.Assert(tf.greater(tf.shape(proposals)[0], 0), [proposals],name="roi_assertion"),]with tf.control_dependencies(asserts):proposals = tf.identity(proposals)# Remove zero padding#去除padding的0proposals, _ = trim_zeros_graph(proposals, name="trim_proposals")gt_boxes, non_zeros = trim_zeros_graph(gt_boxes, name="trim_gt_boxes")gt_class_ids = tf.boolean_mask(gt_class_ids, non_zeros,name="trim_gt_class_ids")gt_masks = tf.gather(gt_masks, tf.where(non_zeros)[:, 0], axis=2,name="trim_gt_masks")#这里crowds没看懂 gt_class_ids < 0 ??# Handle COCO crowds# A crowd box in COCO is a bounding box around several instances. Exclude# them from training. A crowd box is given a negative class ID.crowd_ix = tf.where(gt_class_ids < 0)[:, 0]non_crowd_ix = tf.where(gt_class_ids > 0)[:, 0]crowd_boxes = tf.gather(gt_boxes, crowd_ix)crowd_masks = tf.gather(gt_masks, crowd_ix, axis=2)gt_class_ids = tf.gather(gt_class_ids, non_crowd_ix)gt_boxes = tf.gather(gt_boxes, non_crowd_ix)gt_masks = tf.gather(gt_masks, non_crowd_ix, axis=2)#计算proposals和gt_boxes的覆盖度矩阵proposals*gt_boxes# Compute overlaps matrix [proposals, gt_boxes]overlaps = overlaps_graph(proposals, gt_boxes)# Compute overlaps with crowd boxes [anchors, crowds]crowd_overlaps = overlaps_graph(proposals, crowd_boxes)crowd_iou_max = tf.reduce_max(crowd_overlaps, axis=1)no_crowd_bool = (crowd_iou_max < 0.001)# Determine postive and negative ROIs#获得proposals和gt_box最大的覆盖度值[n_proposals,1]roi_iou_max = tf.reduce_max(overlaps, axis=1)# 1. Positive ROIs are those with >= 0.5 IoU with a GT box#roi覆盖度值>0.5则认为其是positive_roi bool[n_proposals,1]positive_roi_bool = (roi_iou_max >= 0.5)#获取positive_roi的索引[filter_n_proposals,1]positive_indices = tf.where(positive_roi_bool)[:, 0]# 2. Negative ROIs are those with < 0.5 with every GT box. Skip crowds.negative_indices = tf.where(tf.logical_and(roi_iou_max < 0.5, no_crowd_bool))[:, 0]#对positive_roi和inegative_roi进行了采样# Subsample ROIs. Aim for 33% positive# Positive ROIspositive_count = int(config.TRAIN_ROIS_PER_IMAGE *config.ROI_POSITIVE_RATIO)positive_indices = tf.random_shuffle(positive_indices)[:positive_count]positive_count = tf.shape(positive_indices)[0]# Negative ROIs. Add enough to maintain positive:negative ratio.r = 1.0 / config.ROI_POSITIVE_RATIOnegative_count = tf.cast(r * tf.cast(positive_count, tf.float32), tf.int32) - positive_countnegative_indices = tf.random_shuffle(negative_indices)[:negative_count]# Gather selected ROIspositive_rois = tf.gather(proposals, positive_indices)negative_rois = tf.gather(proposals, negative_indices)#把采样后的positive_roi分配给gt_box# Assign positive ROIs to GT boxes.positive_overlaps = tf.gather(overlaps, positive_indices)#每个positive_rois对应gt_box覆盖度最大值的下标(即列下标)[filter_n_proposals,1]roi_gt_box_assignment = tf.argmax(positive_overlaps, axis=1)roi_gt_boxes = tf.gather(gt_boxes, roi_gt_box_assignment)roi_gt_class_ids = tf.gather(gt_class_ids, roi_gt_box_assignment)# Compute bbox refinement for positive ROIsdeltas = utils.box_refinement_graph(positive_rois, roi_gt_boxes)deltas /= config.BBOX_STD_DEV# Assign positive ROIs to GT masks# Permute masks to [N, height, width, 1]transposed_masks = tf.expand_dims(tf.transpose(gt_masks, [2, 0, 1]), -1)# Pick the right mask for each ROIroi_masks = tf.gather(transposed_masks, roi_gt_box_assignment)# Compute mask targets....# Append negative ROIs and pad bbox deltas and masks that# are not used for negative ROIs with zeros.rois = tf.concat([positive_rois, negative_rois], axis=0)N = tf.shape(negative_rois)[0]P = tf.maximum(config.TRAIN_ROIS_PER_IMAGE - tf.shape(rois)[0], 0)rois = tf.pad(rois, [(0, P), (0, 0)])roi_gt_boxes = tf.pad(roi_gt_boxes, [(0, N + P), (0, 0)])roi_gt_class_ids = tf.pad(roi_gt_class_ids, [(0, N + P)])deltas = tf.pad(deltas, [(0, N + P), (0, 0)])masks = tf.pad(masks, [[0, N + P], (0, 0), (0, 0)])#....return rois, roi_gt_class_ids, deltas, masks

1.6Network Heads
经过DetectionTargetLayer层生成了很多rois，但它们大小不一，这里需要对其进行大小归一处理，并和之前的FPN生成的feature_map联系起来。

# Network Heads
# TODO: verify that this handles zero padded ROIs
mrcnn_class_logits, mrcnn_class, mrcnn_bbox =\fpn_classifier_graph(rois, mrcnn_feature_maps, input_image_meta,config.POOL_SIZE, config.NUM_CLASSES,train_bn=config.TRAIN_BN)

然后进入到***fpn_classifier_graph***函数，首先通过PyramidROIAlign层获得rois固定pooling大小输出，之后用了2个fc层特征化了feature_map，和上面提及的RPN类似对类别进行分类，对4个坐标点进行回归。

def fpn_classifier_graph(rois, feature_maps, image_meta,pool_size, num_classes, train_bn=True):"""Builds the computation graph of the feature pyramid network classifierand regressor heads.rois: [batch, num_rois, (y1, x1, y2, x2)] Proposal boxes in normalizedcoordinates.feature_maps: List of feature maps from diffent layers of the pyramid,[P2, P3, P4, P5]. Each has a different resolution.- image_meta: [batch, (meta data)] Image details. See compose_image_meta()pool_size: The width of the square feature map generated from ROI Pooling.num_classes: number of classes, which determines the depth of the resultstrain_bn: Boolean. Train or freeze Batch Norm layresReturns:logits: [N, NUM_CLASSES] classifier logits (before softmax)probs: [N, NUM_CLASSES] classifier probabilitiesbbox_deltas: [N, (dy, dx, log(dh), log(dw))] Deltas to apply toproposal boxes"""# ROI Pooling# Shape: [batch, num_boxes, pool_height, pool_width, channels]x = PyramidROIAlign([pool_size, pool_size],name="roi_align_classifier")([rois, image_meta] + feature_maps)# Two 1024 FC layers (implemented with Conv2D for consistency)x = KL.TimeDistributed(KL.Conv2D(1024, (pool_size, pool_size), padding="valid"),name="mrcnn_class_conv1")(x)x = KL.TimeDistributed(BatchNorm(), name='mrcnn_class_bn1')(x, training=train_bn)x = KL.Activation('relu')(x)x = KL.TimeDistributed(KL.Conv2D(1024, (1, 1)),name="mrcnn_class_conv2")(x)x = KL.TimeDistributed(BatchNorm(), name='mrcnn_class_bn2')(x, training=train_bn)x = KL.Activation('relu')(x)shared = KL.Lambda(lambda x: K.squeeze(K.squeeze(x, 3), 2),name="pool_squeeze")(x)# Classifier headmrcnn_class_logits = KL.TimeDistributed(KL.Dense(num_classes),name='mrcnn_class_logits')(shared)mrcnn_probs = KL.TimeDistributed(KL.Activation("softmax"),name="mrcnn_class")(mrcnn_class_logits)# BBox head# [batch, boxes, num_classes * (dy, dx, log(dh), log(dw))]x = KL.TimeDistributed(KL.Dense(num_classes * 4, activation='linear'),name='mrcnn_bbox_fc')(shared)# Reshape to [batch, boxes, num_classes, (dy, dx, log(dh), log(dw))]s = K.int_shape(x)mrcnn_bbox = KL.Reshape((s[1], num_classes, 4), name="mrcnn_bbox")(x)return mrcnn_class_logits, mrcnn_probs, mrcnn_bbox

下面重点看下***PyramidROIAlign***
首先关注一个问题：roi来自于哪个feature_map(P2-P5对应的featrue_map) ? 也就是说对应给定的roi，应该去哪个feature_map上做ROIAlign？因为之前生成anchor数目过多，没有记录其来自哪个feature_map，论文提出了一个近似的计算公式：（截图来自于FPN网络原论文）

然后在看代码就清晰多了，至于roialign，代码直接调用了tf.image.crop_and_resize函数，这里有个较好的roi_pooling博文：https://blog.deepsense.ai/region-of-interest-pooling-explained/

class PyramidROIAlign(KE.Layer):"""Implements ROI Pooling on multiple levels of the feature pyramid.Params:- pool_shape: [height, width] of the output pooled regions. Usually [7, 7]Inputs:- boxes: [batch, num_boxes, (y1, x1, y2, x2)] in normalizedcoordinates. Possibly padded with zeros if not enoughboxes to fill the array.- image_meta: [batch, (meta data)] Image details. See compose_image_meta()- Feature maps: List of feature maps from different levels of the pyramid.Each is [batch, height, width, channels]Output:Pooled regions in the shape: [batch, num_boxes, height, width, channels].The width and height are those specific in the pool_shape in the layerconstructor."""def __init__(self, pool_shape, **kwargs):super(PyramidROIAlign, self).__init__(**kwargs)self.pool_shape = tuple(pool_shape)def call(self, inputs):# Crop boxes [batch, num_boxes, (y1, x1, y2, x2)] in normalized coordsboxes = inputs[0]# Image meta# Holds details about the image. See compose_image_meta()image_meta = inputs[1]# Feature Maps. List of feature maps from different level of the# feature pyramid. Each is [batch, height, width, channels]feature_maps = inputs[2:]# Assign each ROI to a level in the pyramid based on the ROI area.y1, x1, y2, x2 = tf.split(boxes, 4, axis=2)h = y2 - y1w = x2 - x1# Use shape of first image. Images in a batch must have the same size.image_shape = parse_image_meta_graph(image_meta)['image_shape'][0]# Equation 1 in the Feature Pyramid Networks paper. Account for# the fact that our coordinates are normalized here.# e.g. a 224x224 ROI (in pixels) maps to P4image_area = tf.cast(image_shape[0] * image_shape[1], tf.float32)roi_level = log2_graph(tf.sqrt(h * w) / (224.0 / tf.sqrt(image_area)))roi_level = tf.minimum(5, tf.maximum(2, 4 + tf.cast(tf.round(roi_level), tf.int32)))roi_level = tf.squeeze(roi_level, 2)# Loop through levels and apply ROI pooling to each. P2 to P5.pooled = []box_to_level = []for i, level in enumerate(range(2, 6)):ix = tf.where(tf.equal(roi_level, level))level_boxes = tf.gather_nd(boxes, ix)# Box indicies for crop_and_resize.box_indices = tf.cast(ix[:, 0], tf.int32)# Keep track of which box is mapped to which levelbox_to_level.append(ix)# Stop gradient propogation to ROI proposalslevel_boxes = tf.stop_gradient(level_boxes)box_indices = tf.stop_gradient(box_indices)# Crop and Resize# From Mask R-CNN paper: "We sample four regular locations, so# that we can evaluate either max or average pooling. In fact,# interpolating only a single value at each bin center (without# pooling) is nearly as effective."## Here we use the simplified approach of a single value per bin,# which is how it's done in tf.crop_and_resize()# Result: [batch * num_boxes, pool_height, pool_width, channels]pooled.append(tf.image.crop_and_resize(feature_maps[i], level_boxes, box_indices, self.pool_shape,method="bilinear"))# Pack pooled features into one tensorpooled = tf.concat(pooled, axis=0)#.....

1.7build_fpn_mask_graph
在roi的基础上用了一个简易版的FCN网络进行mask (简易版？FPN网络也具有不同层次的抽象特征)

mrcnn_mask = build_fpn_mask_graph(rois, mrcnn_feature_maps,input_image_meta,config.MASK_POOL_SIZE,config.NUM_CLASSES,train_bn=config.TRAIN_BN)def build_fpn_mask_graph(rois, feature_maps, image_meta,pool_size, num_classes, train_bn=True):"""Builds the computation graph of the mask head of Feature Pyramid Network.rois: [batch, num_rois, (y1, x1, y2, x2)] Proposal boxes in normalizedcoordinates.feature_maps: List of feature maps from diffent layers of the pyramid,[P2, P3, P4, P5]. Each has a different resolution.image_meta: [batch, (meta data)] Image details. See compose_image_meta()pool_size: The width of the square feature map generated from ROI Pooling.num_classes: number of classes, which determines the depth of the resultstrain_bn: Boolean. Train or freeze Batch Norm layresReturns: Masks [batch, roi_count, height, width, num_classes]"""# ROI Pooling# Shape: [batch, boxes, pool_height, pool_width, channels]x = PyramidROIAlign([pool_size, pool_size],name="roi_align_mask")([rois, image_meta] + feature_maps)# Conv layersx = KL.TimeDistributed(KL.Conv2D(256, (3, 3), padding="same"),name="mrcnn_mask_conv1")(x)x = KL.TimeDistributed(BatchNorm(),name='mrcnn_mask_bn1')(x, training=train_bn)x = KL.Activation('relu')(x)x = KL.TimeDistributed(KL.Conv2D(256, (3, 3), padding="same"),name="mrcnn_mask_conv2")(x)x = KL.TimeDistributed(BatchNorm(),name='mrcnn_mask_bn2')(x, training=train_bn)x = KL.Activation('relu')(x)x = KL.TimeDistributed(KL.Conv2D(256, (3, 3), padding="same"),name="mrcnn_mask_conv3")(x)x = KL.TimeDistributed(BatchNorm(),name='mrcnn_mask_bn3')(x, training=train_bn)x = KL.Activation('relu')(x)x = KL.TimeDistributed(KL.Conv2D(256, (3, 3), padding="same"),name="mrcnn_mask_conv4")(x)x = KL.TimeDistributed(BatchNorm(),name='mrcnn_mask_bn4')(x, training=train_bn)x = KL.Activation('relu')(x)x = KL.TimeDistributed(KL.Conv2DTranspose(256, (2, 2), strides=2, activation="relu"),name="mrcnn_mask_deconv")(x)x = KL.TimeDistributed(KL.Conv2D(num_classes, (1, 1), strides=1, activation="sigmoid"),name="mrcnn_mask")(x)return x

前面4个卷积feature_map_size保存不变，然后接了一个逆卷积Conv2DTranspose，feature_map_size变成了之前的2倍(类似于上采样)，这和配置文件中的参数是对应：

MASK_POOL_SIZE = 14
# Shape of output mask
# To change this you also need to change the neural network mask branch
MASK_SHAPE = [28, 28]

1.8 loss+model
下面是loss和keras模型生成的部分

  # Losses
rpn_class_loss = KL.Lambda(lambda x: rpn_class_loss_graph(*x), name="rpn_class_loss")([input_rpn_match, rpn_class_logits])
rpn_bbox_loss = KL.Lambda(lambda x: rpn_bbox_loss_graph(config, *x), name="rpn_bbox_loss")([input_rpn_bbox, input_rpn_match, rpn_bbox])
class_loss = KL.Lambda(lambda x: mrcnn_class_loss_graph(*x), name="mrcnn_class_loss")([target_class_ids, mrcnn_class_logits, active_class_ids])
bbox_loss = KL.Lambda(lambda x: mrcnn_bbox_loss_graph(*x), name="mrcnn_bbox_loss")([target_bbox, target_class_ids, mrcnn_bbox])
mask_loss = KL.Lambda(lambda x: mrcnn_mask_loss_graph(*x), name="mrcnn_mask_loss")([target_mask, target_class_ids, mrcnn_mask])# Model
inputs = [input_image, input_image_meta,input_rpn_match, input_rpn_bbox, input_gt_class_ids, input_gt_boxes, input_gt_masks]
if not config.USE_RPN_ROIS:inputs.append(input_rois)
outputs = [rpn_class_logits, rpn_class, rpn_bbox,mrcnn_class_logits, mrcnn_class, mrcnn_bbox, mrcnn_mask,rpn_rois, output_rois,rpn_class_loss, rpn_bbox_loss, class_loss, bbox_loss, mask_loss]
model = KM.Model(inputs, outputs, name='mask_rcnn')

Summary:

**1.**由FPN网络获得feature_map[P2, P3, P4, P5, P6],并获取其对应下的anchor集合
2.feature_map[P2-P6]依次通过RNP网络，获得对应的[“rpn_class_logits”, “rpn_class”, “rpn_bbox”],这里对坐标进行了第1次线性回归。
3.ProposalLayer把RNP网络生成的[“rpn_class”, “rpn_bbox”]和Anchor对应起来,对前景概率FG降序并取前N(N=6000)个对应的indics,并由此indics获得对应的rpn_bbox(deltas)和anchors(pre_nms_anchors),然后利用deltas对pre_nms_anchors进行坐标修正。最后用极大值抑制算法对修正后的anchors进行过滤获得rois
4.DetectionTargetLayer根据roi和gt_box的iou(交并比)划分positive_roi和negative_roi.取其比例1:3，最终返回
5.fpn_classifier_graph把roi和feature_map[P2-P6]联系起来，首先把roi在对应的feature_map进行roi_pooling获得固定大小的feature_map(77),然后在feature_map(77)的基础上进行类别分类和第2次坐标线性回归