下面来看一下stage1_rpn_train.pt这个网络的内部结构。
“ZF”网络结构
一、数据输入层:
从roi_data_layer.layer文件中得到数据, 进入到roi_data_layer.layer文件中,查看forward函数,这个函数的top变量就是输出结果。下面进入forward函数:
blobs =self._get_next_minibatch() :首先根据self._get_next_minibatch() 函数得到符合caffe格式的blobs。
看一下self._get_next_minibatch() 函数:
由于__C.TRAIN.USE_PREFETCH =False,所以执行else语句。
首先,根据_get_next_minibatch_inds函数得到db_inds,进入_get_next_minibatch_inds函数:
注意,虽然在config文件中cfg.TRAIN.IMS_PER_BATCH的值为2,但是在train_rpn函数中,将其修改为了1,因此:cfg.TRAIN.IMS_PER_BATCH = 1
关于self._perm:
所以,最后得到的db_inds是从np.random.permutation(np.arange(len(self._roidb)))得到的一个元素,也即是:从self._roidb中随机选取一个数值,那么self._roidb又是什么呢?回想set_roidb函数,在这个函数中,将我们得到的准备数据roidb进行随机打乱,得到了:self._roidb。(从这里可以看出,得到的db_inds实际上是把roidb打乱了2次)。
好了,回到_get_next_minibatch函数:
minibatch_db = [self._roidb[i] for i in db_inds]:根据得到的db_inds中,从self._roidb中取出这张图片对应的数据,我们知道是一个字典,然后把这些字典数据组成一个列表minibatch_db (虽然这个列表只有一个元素)。
最后,使用get_minibatch(minibatch_db,self._num_classes)函数,将minibatch_db 转换为blobs。
get_minibatch是一个比较复杂的函数,进入get_minibatch函数:
在这里,利用_get_image_blob函数得到两个输出值im_blob(是一个列表,虽然这里的列表长度为1) 和 im_scales(是一个列表,虽然这里的列表长度为1)。进入_get_image_blob函数看一下:
首先,利用prep_im_for_blob函数来得到每张图片的 im 和 im_scale,然后将它们添加到图片列表processed_ims和缩放比例列表:im_scales。接下来,使用im_list_to_blob函数将图片列表processed_ims转换成blob。然后,将blob 和 im_scales返回。
好了,回到get_minibatch函数,我们得到了im_blob(一个batch的blob),以及在这个batch中每张图片的缩放比例列表im_scales。(注意,这里的batch=1,即:blob的第一个维度为1。im_scales的长度也为1)
这里可以看出,blobs是一个字典,首先,将上面得到的im_blob传入blobs字典。
然后判断cfg.TRAIN.HAS_RPN,注意,在train_rpn函数中:cfg.TRAIN.HAS_RPN =True,所以,这里要执行if语句:判断assert len(im_scales) ==1和assert len(roidb) ==1,经过我们的分析,可以看出,这两个条件是成立的。
gt_inds = np.where(roidb[0]['gt_classes'] !=0)[0]:因为gt_classes = np.zeros((num_objs),dtype=np.int32),所以,gt_inds 得到的是gt_classes 的行索引,因为gt_classes 对应的是图片中的真实物体矩阵,没有非0值,所以gt_inds 得到的是gt_classes 中所有的行索引。
gt_boxes是一个num_objs行5列的矩阵,其中前面四列是:每个gt_box对应的坐标,第5列是:物体号。
好了,get_minibatch函数结束,回到_get_next_minibatch函数,最后的返回值是一个blobs字典,
blobs = { 'data': im_blob, 'gt_boxes':gt_boxes, 'im_info':np.array([高度,宽度, 缩放比例]) }
接下来,返回forward函数,遍历blobs 字典,得到:
top[0] = blobs['data']、 top[1] = blobs['im_info'] 、 top[2] = blobs['gt_boxes'] 。
这样,forward函数结束,得到了top变量。回到‘ZF’网络中:
可以看到,得到的top就是这个网络层中的输出结果。
二、基础的网络层(总共包含5个卷积过程)
接着看下面的网络结构,一开始是:
#========= 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
}
}
输入是上面得到的‘data',输出96个通道,卷积核的大小7,补零(补3圈),卷积的stride=2
接下来,一直到conv5 结束,都是一样分析,具体的内容可以参考:https://blog.csdn.net/Seven_year_Promise/article/details/60954553
而且conv5 的输出结果为:batch*256*14*14 。(根据设置,我们知道,这里的batch=1)
三、RPN层
首先看一下RPN层的网络结构:
我们得到的batch*256*14*14 就是图中的feature map,首先进行了一个3*3的卷积,输出的结果还是batch*256*14*14 ,然后分两个方向:
第一个方向,进行1*1*18的卷积,得到的结果为:batch*18*14*14 。根据结果可以看出,这里相当于在特征图的每个格子中取了9个anchor,每个anchor有foreground和background(检测目标是foreground),所以刚好是18个通道。然后进行softmax分类获得foreground anchors,也就相当于初步提取了检测目标候选区域box(一般认为目标在foreground anchors中)。
那么为何要在softmax前后都接一个reshape layer?其实只是为了便于softmax分类,至于具体原因这就要从caffe的实现形式说起了。在caffe基本数据结构blob中以如下形式保存数据:
blob=[batch_size, channel,height,width]
对应至上面的保存bg/fg anchors的矩阵,其在caffe blob中的存储形式为[1, 2*9, 14, 14]。而在softmax分类时需要进行fg/bg二分类,所以reshape layer会将其变为[1, 2, 9*14, 14]大小,即单独“腾空”出来一个维度以便softmax分类,之后再reshape回复原状。
第二个方向,进行1*1*36的卷积,得到的结果为:batch*36*14*14 (实际上是:[1, 4*9, 14, 14])。也就是每个anchor会得到4个偏移量。
下面看具体的代码:
#========= RPN ============
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"
}
这里是进行了3*3的卷积,然后又接了一个relu的激活函数。
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 # 2(bg/fg) * 9(anchors)
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 # 4 * 9(anchors)
kernel_size: 1 pad: 0 stride: 1
weight_filler { type: "gaussian" std: 0.01 }
bias_filler { type: "constant" value: 0 }
}
}
这两层分别是两个方向,用1*1*18的卷积,得到:rpn_cls_score([1, 2*9, 14, 14]);
1*1*36的卷积,得到:rpn_bbox_pred([1, 4*9, 14, 14])。
下面将rpn_cls_score改变维度:
通过reshape层,将rpn_cls_score进行reshape,得到:rpn_cls_score_reshape([1, 2, 9*14, 14])。
(关于caffe的reshape层:
#dim:0 表示维度不变,即输入和输出是相同的维度。
#dim:2 表示将原来的维度变成2。
#dim:-1 表示由系统自动计算维度,数据的总量不变。)
我们知道,rpn_cls_score(或者说:rpn_cls_score_reshape)和rpn_bbox_pred是网络预测的rpn_box,而且,我们下一步需要对这两个结果计算loss,那么计算loss所需要的target在哪里呢,下面我们需要计算target:
先来看一下参数:param_str: "'feat_stride': 16",这个实际上表示:图片经过一系列卷积,到现在的feature map缩小了多少倍,也就是说,我们的经过缩放之后的图片经过了最初的五层卷积,高度和宽度都变为了原来的1/16(后面的3*3卷积和1*1卷积之后,feature map大小不变,所以没有计算在内)
再来看一下这一层的输入和输出:
输入:
bottom: 'rpn_cls_score' (1*1*18卷积的结果)
bottom: 'gt_boxes' (roi_data_layer.layer的输出结果,num_obj行5列的矩阵,前4列是坐标,第5列是物体号)
bottom: 'im_info' (roi_data_layer.layer的输出结果, [高度,宽度, 缩放比例],这里的高度和宽度是缩放之后的)
bottom: 'data' (roi_data_layer.layer的输出结果, 4维矩阵,(batch, 3,高度,宽度),batch=1)
输出:
top: 'rpn_labels' :
先看一个中间变量labels:height * width *9 个元素的一维向量(height、width 是feature map的高度和宽度),也就是说labels刚好和总的anchor的数量是对应的。然后将labels进行两次reshape:
labels = labels.reshape((1, height, width, A)).transpose(0,3,1,2),
labels = labels.reshape((1,1, A * height, width))
得到rpn_labels,我们对比一下 rpn_labels的维度:(1,1, 9* 14, 14) 和 rpn_cls_score_reshape的维度(1, 2, 9*14, 14)。发现不太一样,由于对caffe不太熟悉,不知道在计算rpn_loss_cls的时候,是否对rpn_labels进行了后续处理。(当然,这里如果要把rpn_labels和rpn_cls_score_reshape的维度变成一样也很容易处理,进行one_hot处理就可以了)。
top: 'rpn_bbox_targets':
同样的,先看就中间变量bbox_targets,这是一个:height * width *9行4列的矩阵(列元素:tx,ty,tw,th)。然后进行reshape和转置,bbox_targets = bbox_targets .reshape((1, height, width, A *4)).transpose(0,3,1,2)。
那么,最后得到的维度是(1,A *4,height, width)。和rpn_bbox_pred的维度是一致的。
top: 'rpn_bbox_inside_weights':和 'rpn_bbox_targets'是一样的操作,先是得到 height * width *9行4列的矩阵(计算rpn_loss_bbox用到,没找到具体的rpn_loss_bbox文件),然后进行reshape和转置,最终得到的结果维度是:(1,A *4*,height, width)。
top: 'rpn_bbox_outside_weights':和 'rpn_bbox_targets'是一样的操作,先是得到 height * width *9行4列的矩阵(计算rpn_loss_bbox用到,没找到具体的rpn_loss_bbox文件),然后进行reshape和转置,最终得到的结果维度是:(1,A *4*,height, width)。
好了,下面进入rpn.anchor_target_layer文件,具体来看一下上述的结果是怎么实现的,直接看forward函数:
首先,判断batch是否为1,否则报错。然后根据输入得到基本信息:
可以得到:每个格子生成9个anchor,总共有K个格子(K=14*14=196),那么anchor的总数为:K*A个。
所有的anchor具体的坐标为:all_anchors,这是一个K*A行4列的矩阵。
注意:这个生成的all_anchors不是feature map的anchor,而是缩放后的图片的anchor,因为在生成这些anchor的过程中,乘以了系数self._feat_stride(值为:16)。
然后,过滤all_anchors,只保留没有超出图片的anchor:
过滤anchor之后,设置label的值,labels分为三类:1(代表正样本)、0(负样本)、-1(直接丢弃)。
然后,判断anchor和gt_box的overlap(即:IOU):
(1)先求overlaps矩阵:
overlaps = bbox_overlaps ( np.ascontiguousarray(anchors,dtype=np.float) \
,np.ascontiguousarray(gt_boxes,dtype=np.float) ),结果是一个inds_inside行num_obj列的矩阵
(2)对于每一个gt_box来说,和它的重叠区域最大的那个anchor的labels设为:1(即为:正样本),也就是在overlaps 矩阵中,按照列求最大值,那么每列最大值对应的行索引号对对应的anchor为正样本
(3)overlaps按照行取最大值,如果最大值大于0.7,那么这行对应的anchor为正样本(labels设为:1)
(4)overlaps按照行取最大值,如果最大值小于0.3,那么这行对应的anchor为负样本(labels设为:0)
(5)正样本的个数num_fg取128个,如果大于128,那么多出的部分直接丢弃(labels设为-1);如果num_fg不够128个,那么用负样本来补;
负样本的个数num_bg取:256-num_fg,同样的,如果num_bg大于256-num_fg,多出的直接丢弃
下面看bbox_targets,bbox_targets和过滤后的anchors ( anchors = all_anchors[inds_inside, :] )是对应的:
注意:这里的bbox_targets中4列的元素值:是坐标的偏移量,而不是坐标。
到这里还没有结束,注意我们这里得到的labels、bbox_targets都是通过过滤之后的anchors得到的,数量只有inds_inside个。但是,我们预测得到的结果是:rpn_cls_score([1, 2*9, 14, 14])(表示:anchor的个数是:9*14*14),这个数量和我们过滤之前的all_anchors的数量是一样的。所以,下面要经过一个简单的处理,利用_unmap函数将labels和bbox_targets的行的数量重新扩展到total_anchors个。