def build_fastrcnn(self, P_list, rois_list, img_shape): with tf.variable_scope('Fast-RCNN'): # 5. ROI Pooling with tf.variable_scope('rois_pooling'): pooled_features_list = [] for level_name, p, rois in zip(cfgs.LEVLES, P_list, rois_list): # exclude P6_rois # p = tf.Print(p, [tf.shape(p)], summarize=10, message=level_name+'SHPAE***') pooled_features = self.roi_pooling(feature_maps=p, rois=rois, img_shape=img_shape, scope=level_name) pooled_features_list.append(pooled_features) pooled_features = tf.concat( pooled_features_list, axis=0) # [minibatch_size, H, W, C] # 6. inferecne rois in Fast-RCNN to obtain fc_flatten features if self.base_network_name.startswith('resnet'): fc_flatten = resnet.restnet_head( inputs=pooled_features, is_training=self.is_training, scope_name=self.base_network_name) elif self.base_network_name.startswith('Mobile'): fc_flatten = mobilenet_v2.mobilenetv2_head( inputs=pooled_features, is_training=self.is_training) else: raise NotImplementedError('only support resnet and mobilenet') # 7. cls and reg in Fast-RCNN with slim.arg_scope([slim.fully_connected], weights_regularizer=slim.l2_regularizer( cfgs.WEIGHT_DECAY)): cls_score = slim.fully_connected( fc_flatten, num_outputs=cfgs.CLASS_NUM + 1, weights_initializer=cfgs.INITIALIZER, activation_fn=None, trainable=self.is_training, scope='cls_fc') bbox_pred = slim.fully_connected( fc_flatten, num_outputs=(cfgs.CLASS_NUM + 1) * 4, activation_fn=None, trainable=self.is_training, weights_initializer=tf.random_normal_initializer( mean=0.0, stddev=0.001), scope='reg_fc') # for convient. It also produce (cls_num +1) bboxes cls_score = tf.reshape(cls_score, [-1, cfgs.CLASS_NUM + 1]) bbox_pred = tf.reshape(bbox_pred, [-1, 4 * (cfgs.CLASS_NUM + 1)]) return bbox_pred, cls_score
def build_fastrcnn(feature_to_cropped, rois, img_shape, base_network_name, is_training): with tf.variable_scope('Fast-RCNN'): # 1. ROI Pooling with tf.variable_scope('rois_pooling'): pooled_features = roi_pooling(feature_maps=feature_to_cropped, rois=rois, img_shape=img_shape) # 2. inferecne rois in Fast-RCNN to obtain fc_flatten features if base_network_name.startswith('resnet'): fc_flatten = resnet.restnet_head(input=pooled_features, is_training=is_training, scope_name=base_network_name) elif base_network_name.startswith('MobilenetV2'): fc_flatten = mobilenet_v2.mobilenetv2_head(inputs=pooled_features, is_training=is_training) else: raise NotImplementedError('only support resnet and mobilenet') # 3. cls and reg in Fast-RCNN with tf.variable_scope('horizen_branch'): with slim.arg_scope([slim.fully_connected], weights_regularizer=slim.l2_regularizer(cfgs.WEIGHT_DECAY)): cls_score_h = slim.fully_connected(fc_flatten, num_outputs=cfgs.CLASS_NUM + 1, weights_initializer=cfgs.INITIALIZER, activation_fn=None, trainable=is_training, scope='cls_fc_h') bbox_pred_h = slim.fully_connected(fc_flatten, num_outputs=(cfgs.CLASS_NUM + 1) * 4, weights_initializer=cfgs.BBOX_INITIALIZER, activation_fn=None, trainable=is_training, scope='reg_fc_h') # for convient. It also produce (cls_num +1) bboxes cls_score_h = tf.reshape(cls_score_h, [-1, cfgs.CLASS_NUM + 1]) bbox_pred_h = tf.reshape(bbox_pred_h, [-1, 4 * (cfgs.CLASS_NUM + 1)]) with tf.variable_scope('rotation_branch'): with slim.arg_scope([slim.fully_connected], weights_regularizer=slim.l2_regularizer(cfgs.WEIGHT_DECAY)): cls_score_r = slim.fully_connected(fc_flatten, num_outputs=cfgs.CLASS_NUM + 1, weights_initializer=cfgs.INITIALIZER, activation_fn=None, trainable=is_training, scope='cls_fc_r') bbox_pred_r = slim.fully_connected(fc_flatten, num_outputs=(cfgs.CLASS_NUM + 1) * 5, weights_initializer=cfgs.BBOX_INITIALIZER, activation_fn=None, trainable=is_training, scope='reg_fc_r') # for convient. It also produce (cls_num +1) bboxes cls_score_r = tf.reshape(cls_score_r, [-1, cfgs.CLASS_NUM + 1]) bbox_pred_r = tf.reshape(bbox_pred_r, [-1, 5 * (cfgs.CLASS_NUM + 1)]) return bbox_pred_h, cls_score_h, bbox_pred_r, cls_score_r
def build_fastrcnn(self, feature_to_cropped, rois, img_shape): with tf.variable_scope('Fast-RCNN'): # 5. ROI Pooling with tf.variable_scope('rois_pooling'): rois = boxes_utils.get_horizen_minAreaRectangle(rois, False) pooled_features = self.roi_pooling( feature_maps=feature_to_cropped, rois=rois, img_shape=img_shape) # xmin, ymin, xmax, ymax = tf.unstack(rois, axis=1) # # h = tf.maximum(ymax - ymin, 0) # w = tf.maximum(xmax - xmin, 0) # x_c = (xmax + xmin) // 2 # y_c = (ymax + ymin) // 2 # theta = tf.ones_like(h) * -90 # rois = tf.transpose(tf.stack([x_c, y_c, h, w, theta])) # 6. inferecne rois in Fast-RCNN to obtain fc_flatten features if self.base_network_name.startswith('resnet'): fc_flatten = resnet.restnet_head(input=pooled_features, is_training=self.is_training, scope=self.base_network_name) elif self.base_network_name.startswith('MobilenetV2'): fc_flatten = mobilenet_v2.mobilenetv2_head( inputs=pooled_features, is_training=self.is_training) else: raise NotImplementedError('only support resnet and mobilenet') # 7. cls and reg in Fast-RCNN with slim.arg_scope([slim.fully_connected], weights_regularizer=slim.l2_regularizer( cfgs.WEIGHT_DECAY)): cls_score = slim.fully_connected( fc_flatten, num_outputs=cfgs.CLASS_NUM + 1, weights_initializer=cfgs.INITIALIZER, activation_fn=None, trainable=self.is_training, scope='cls_fc') bbox_pred = slim.fully_connected( fc_flatten, num_outputs=(cfgs.CLASS_NUM + 1) * 5, weights_initializer=cfgs.BBOX_INITIALIZER, activation_fn=None, trainable=self.is_training, scope='reg_fc') # for convient. It also produce (cls_num +1) bboxes cls_score = tf.reshape(cls_score, [-1, cfgs.CLASS_NUM + 1]) bbox_pred = tf.reshape(bbox_pred, [-1, 5 * (cfgs.CLASS_NUM + 1)]) return bbox_pred, cls_score
def build_fastrcnn(self, feature_to_cropped, rois, img_shape): with tf.variable_scope('Fast-RCNN'): # 5. ROI Pooling with tf.variable_scope('rois_pooling'): pooled_features = self.roi_pooling(feature_maps=feature_to_cropped, rois=rois, img_shape=img_shape) # 6. inferecne rois in Fast-RCNN to obtain fc_flatten features if self.base_network_name.startswith('resnet'): fc_flatten = resnet.restnet_head(input=pooled_features, is_training=self.is_training, scope_name=self.base_network_name) elif self.base_network_name.startswith('Mobile'): fc_flatten = mobilenet_v2.mobilenetv2_head(inputs=pooled_features, is_training=self.is_training) else: raise NotImplementedError('only support resnet and mobilenet') # 7. cls and reg in Fast-RCNN # tf.variance_scaling_initializer() # tf.VarianceScaling() with slim.arg_scope([slim.fully_connected], weights_regularizer=slim.l2_regularizer(cfgs.WEIGHT_DECAY)): cls_score = slim.fully_connected(fc_flatten, num_outputs=cfgs.CLASS_NUM+1, weights_initializer=slim.variance_scaling_initializer(factor=1.0, mode='FAN_AVG', uniform=True), activation_fn=None, trainable=self.is_training, scope='cls_fc') bbox_pred = slim.fully_connected(fc_flatten, num_outputs=(cfgs.CLASS_NUM+1)*4, weights_initializer=slim.variance_scaling_initializer(factor=1.0, mode='FAN_AVG', uniform=True), activation_fn=None, trainable=self.is_training, scope='reg_fc') # for convient. It also produce (cls_num +1) bboxes cls_score = tf.reshape(cls_score, [-1, cfgs.CLASS_NUM+1]) bbox_pred = tf.reshape(bbox_pred, [-1, 4*(cfgs.CLASS_NUM+1)]) return bbox_pred, cls_score
def build_concat_fastrcnn(self, P_list, all_rois, img_shape): with tf.variable_scope('Fast-RCNN'): # 5.0 concat feature maps: h, w = tf.shape(P_list[0])[1], tf.shape(P_list[0])[2] concat_list = [P_list[0]] for l in range(1, len( cfgs.LEVLES)): # do not concat P6, do not upsample P2 upsample_p = tf.image.resize_bilinear(P_list[l], size=[h, w], name='up_sample_%d' % (l + 2)) concat_list.append(upsample_p) concat_fet = tf.concat(concat_list, axis=-1) if cfgs.CONCAT_CHANNEL != 1024: print("concat channel is not 1024") concat_fet = slim.conv2d(concat_fet, activation_fn=None, num_outputs=cfgs.CONCAT_CHANNEL, kernel_size=[3, 3], padding="SAME", stride=1, scope="concat_fets", biases_initializer=None) # 5.1. ROI Pooling with tf.variable_scope('rois_pooling'): pooled_features = self.roi_pooling(concat_fet, rois=all_rois, img_shape=img_shape, scope="all") # 6. inferecne rois in Fast-RCNN to obtain fc_flatten features if self.base_network_name.startswith('resnet'): fc_flatten = resnet.restnet_head( inputs=pooled_features, is_training=self.is_training, scope_name=self.base_network_name) elif self.base_network_name.startswith('Mobile'): fc_flatten = mobilenet_v2.mobilenetv2_head( inputs=pooled_features, is_training=self.is_training) else: raise NotImplementedError('only support resnet and mobilenet') # 7. cls and reg in Fast-RCNN with slim.arg_scope([slim.fully_connected], weights_regularizer=slim.l2_regularizer( cfgs.WEIGHT_DECAY)): cls_score = slim.fully_connected( fc_flatten, num_outputs=cfgs.CLASS_NUM + 1, weights_initializer=cfgs.INITIALIZER, activation_fn=None, trainable=self.is_training, scope='cls_fc') if cfgs.ADD_EXTR_CONVS_FOR_REG > 0: bbox_input_feat = pooled_features for i in range(cfgs.ADD_EXTR_CONVS_FOR_REG): bbox_input_feat = slim.conv2d(bbox_input_feat, num_outputs=256, kernel_size=[3, 3], stride=1, padding="SAME", scope='extra_conv%d' % i) bbox_input_fc_feat = slim.flatten( bbox_input_feat, scope='bbox_feat_flatten') bbox_pred = slim.fully_connected( bbox_input_fc_feat, num_outputs=(cfgs.CLASS_NUM + 1) * 5, weights_initializer=cfgs.BBOX_INITIALIZER, activation_fn=None, trainable=self.is_training, scope='reg_fc') else: bbox_pred = slim.fully_connected( fc_flatten, num_outputs=(cfgs.CLASS_NUM + 1) * 5, weights_initializer=cfgs.BBOX_INITIALIZER, activation_fn=None, trainable=self.is_training, scope='reg_fc') cls_score = tf.reshape(cls_score, [-1, cfgs.CLASS_NUM + 1]) bbox_pred = tf.reshape(bbox_pred, [-1, 5 * (cfgs.CLASS_NUM + 1)]) return bbox_pred, cls_score
def build_fastrcnn(self, P_list, rois_list, img_shape): with tf.variable_scope('Fast-RCNN'): # 5. ROI Pooling with tf.variable_scope('rois_pooling'): pooled_features_list = [] for level_name, p, rois in zip(cfgs.LEVLES, P_list, rois_list): # exclude P6_rois # p = tf.Print(p, [tf.shape(p)], summarize=10, message=level_name+'SHPAE***') pooled_features = self.roi_pooling(feature_maps=p, rois=rois, img_shape=img_shape, scope=level_name) pooled_features_list.append(pooled_features) pooled_features = tf.concat( pooled_features_list, axis=0) # [minibatch_size, H, W, C] # 6. inferecne rois in Fast-RCNN to obtain fc_flatten features if self.base_network_name.startswith('resnet'): fc_flatten = resnet.restnet_head( inputs=pooled_features, is_training=self.is_training, scope_name=self.base_network_name) elif self.base_network_name.startswith('Mobile'): fc_flatten = mobilenet_v2.mobilenetv2_head( inputs=pooled_features, is_training=self.is_training) else: raise NotImplementedError('only support resnet and mobilenet') # 7. cls and reg in Fast-RCNN with slim.arg_scope([slim.fully_connected], weights_regularizer=slim.l2_regularizer( cfgs.WEIGHT_DECAY)): cls_score = slim.fully_connected( fc_flatten, num_outputs=cfgs.CLASS_NUM + 1, weights_initializer=cfgs.INITIALIZER, activation_fn=None, trainable=self.is_training, scope='cls_fc') # if cfgs.ADD_EXTR_CONVS_FOR_REG > 0: # bbox_input_feat = pooled_features # for i in range(cfgs.ADD_EXTR_CONVS_FOR_REG): # bbox_input_feat = slim.conv2d(bbox_input_feat, num_outputs=256, kernel_size=[3, 3], stride=1, # padding="SAME", scope='extra_conv%d' % i) # bbox_input_fc_feat = slim.flatten(bbox_input_feat, scope='bbox_feat_flatten') # # bbox_pred = slim.fully_connected(bbox_input_fc_feat, # num_outputs=(cfgs.CLASS_NUM + 1) * 5, # weights_initializer=cfgs.BBOX_INITIALIZER, # activation_fn=None, trainable=self.is_training, # scope='reg_fc') # else: # bbox_pred = slim.fully_connected(fc_flatten, # num_outputs=(cfgs.CLASS_NUM + 1) * 5, # weights_initializer=cfgs.BBOX_INITIALIZER, # activation_fn=None, trainable=self.is_training, # scope='reg_fc') bbox_input_feat = pooled_features for i in range(cfgs.ADD_EXTR_CONVS_FOR_REG): bbox_input_feat = slim.conv2d(bbox_input_feat, num_outputs=256, kernel_size=[3, 3], stride=1, padding="SAME", scope='extra_conv%d' % i) bbox_input_fc_feat = slim.flatten(bbox_input_feat, scope='bbox_feat_flatten') bbox_pred = slim.fully_connected( bbox_input_fc_feat, num_outputs=(cfgs.CLASS_NUM + 1) * 5, weights_initializer=cfgs.BBOX_INITIALIZER, activation_fn=None, trainable=self.is_training, scope='reg_fc') cls_score = tf.reshape(cls_score, [-1, cfgs.CLASS_NUM + 1]) bbox_pred = tf.reshape(bbox_pred, [-1, 4 * (cfgs.CLASS_NUM + 1)]) cls_score = tf.reshape(cls_score, [-1, cfgs.CLASS_NUM + 1]) bbox_pred = tf.reshape(bbox_pred, [-1, 5 * (cfgs.CLASS_NUM + 1)]) return bbox_pred, cls_score
def build_fastrcnn(self, feature_to_cropped, rois, img_shape, scope): with tf.variable_scope('Fast-RCNN_{}'.format(scope)): # 5. ROI Pooling with tf.variable_scope('rois_pooling'): pooled_features = self.roi_pooling( feature_maps=feature_to_cropped, rois=rois, img_shape=img_shape) # 6. inferecne rois in Fast-RCNN to obtain fc_flatten features if self.base_network_name.startswith('resnet'): fc_flatten = resnet.restnet_head( input=pooled_features, is_training=self.is_training, scope_name=self.base_network_name, stage=scope) else: raise NotImplementedError('only support resnet and mobilenet') # 7. cls and reg in Fast-RCNN # tf.variance_scaling_initializer() # tf.VarianceScaling() with slim.arg_scope([slim.fully_connected], weights_regularizer=slim.l2_regularizer( cfgs.WEIGHT_DECAY)): if not scope == 'stage3': cls_score = slim.fully_connected( fc_flatten, num_outputs=cfgs.CLASS_NUM + 1, weights_initializer=slim.variance_scaling_initializer( factor=1.0, mode='FAN_AVG', uniform=True), activation_fn=None, trainable=self.is_training, scope='cls_fc_h') bbox_pred = slim.fully_connected( fc_flatten, num_outputs=(cfgs.CLASS_NUM + 1) * 5, weights_initializer=slim.variance_scaling_initializer( factor=1.0, mode='FAN_AVG', uniform=True), activation_fn=None, trainable=self.is_training, scope='reg_fc_h') # for convient. It also produce (cls_num +1) bboxes cls_score = tf.reshape(cls_score, [-1, cfgs.CLASS_NUM + 1]) bbox_pred = tf.reshape(bbox_pred, [-1, 5 * (cfgs.CLASS_NUM + 1)]) bbox_pred_ins = tf.reshape(bbox_pred, [-1, cfgs.CLASS_NUM + 1, 5]) # only keep a box which score is the bigest keep_abox = tf.argmax(cls_score, axis=1) keep_inds = tf.reshape( tf.transpose( tf.stack([ tf.cumsum(tf.ones_like(keep_abox)) - 1, keep_abox ])), [-1, 2]) bbox_pred_fliter = tf.reshape( tf.gather_nd(bbox_pred_ins, keep_inds), [-1, 5]) return bbox_pred_fliter, bbox_pred, cls_score else: cls_score = slim.fully_connected( fc_flatten, num_outputs=cfgs.CLASS_NUM + 1, weights_initializer=slim.variance_scaling_initializer( factor=1.0, mode='FAN_AVG', uniform=True), activation_fn=None, trainable=self.is_training, scope='cls_fc_r') bbox_pred = slim.fully_connected( fc_flatten, num_outputs=(cfgs.CLASS_NUM + 1) * 5, weights_initializer=slim.variance_scaling_initializer( factor=1.0, mode='FAN_AVG', uniform=True), activation_fn=None, trainable=self.is_training, scope='reg_fc_r') cls_score = tf.reshape(cls_score, [-1, cfgs.CLASS_NUM + 1]) bbox_pred = tf.reshape(bbox_pred, [-1, 5 * (cfgs.CLASS_NUM + 1)]) return bbox_pred, cls_score
def build_whole_detection_network(self, input_img_batch, gtboxes_batch): if self.is_training: # ensure shape is [M, 5] gtboxes_batch = tf.reshape(gtboxes_batch, [-1, 5]) gtboxes_batch = tf.cast(gtboxes_batch, tf.float32) img_shape = tf.shape(input_img_batch) # 1.0 build base network rpn_base = self.build_base_network(input_img_batch) # 1.1 build the head_base network if self.base_network_name.startswith('resnet_v1'): rfcn_base = resnet.restnet_head(rpn_base, scope_name=self.base_network_name, is_training=self.is_training) elif self.base_network_name.startswith('MobilenetV2'): rfcn_base = mobilenet_v2.mobilenetv2_head( rpn_base, is_training=self.is_training) else: raise ValueError('Sorry, we only support resnet or mobilenet_v2') # 2. build rpn head with tf.variable_scope('build_rpn', regularizer=slim.l2_regularizer( cfgs.WEIGHT_DECAY)): rpn_conv3x3 = slim.conv2d(rpn_base, 128, [3, 3], trainable=self.is_training, weights_initializer=cfgs.INITIALIZER, activation_fn=tf.nn.relu, scope='rpn_conv/3x3') 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, scope='rpn_cls_score') 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, scope='rpn_bbox_pred') rpn_box_pred = tf.reshape(rpn_box_pred, [-1, 4]) rpn_cls_score = tf.reshape(rpn_cls_score, [-1, 2]) rpn_cls_prob = slim.softmax(rpn_cls_score, scope='rpn_cls_prob') # 3. generate_anchors featuremap_height, featuremap_width = tf.shape(rpn_base)[1], tf.shape( rpn_base)[2] featuremap_height = tf.cast(featuremap_height, tf.float32) featuremap_width = tf.cast(featuremap_width, tf.float32) anchors = anchor_utils.make_anchors( base_anchor_size=cfgs.BASE_ANCHOR_SIZE_LIST[0], anchor_scales=cfgs.ANCHOR_SCALES, anchor_ratios=cfgs.ANCHOR_RATIOS, featuremap_height=featuremap_height, featuremap_width=featuremap_width, stride=cfgs.ANCHOR_STRIDE, name="make_anchors_forRPN") # 4. postprocess rpn proposals. such as: decode, clip, NMS with tf.variable_scope('postprocess_RPN'): rois, roi_scores = postprocess_rpn_proposals( rpn_bbox_pred=rpn_box_pred, rpn_cls_prob=rpn_cls_prob, img_shape=img_shape, anchors=anchors, is_training=self.is_training) # rois shape [-1, 4] # +++++++++++++++++++++++++++++++++++++add img smry+++++++++++++++++++++++++++++++++++++++++++++++++++++++ if self.is_training: rois_in_img = show_box_in_tensor.draw_boxes_with_scores( img_batch=input_img_batch, boxes=rois, scores=roi_scores) tf.summary.image('all_rpn_rois', rois_in_img) score_gre_05 = tf.reshape( tf.where(tf.greater_equal(roi_scores, 0.5)), [-1]) score_gre_05_rois = tf.gather(rois, score_gre_05) score_gre_05_score = tf.gather(roi_scores, score_gre_05) score_gre_05_in_img = show_box_in_tensor.draw_boxes_with_scores( img_batch=input_img_batch, boxes=score_gre_05_rois, scores=score_gre_05_score) tf.summary.image('score_greater_05_rois', score_gre_05_in_img) # ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ if self.is_training: with tf.variable_scope('sample_anchors_minibatch'): rpn_labels, rpn_bbox_targets = \ tf.py_func( anchor_target_layer, [gtboxes_batch, img_shape, anchors], [tf.float32, tf.float32]) rpn_bbox_targets = tf.reshape(rpn_bbox_targets, [-1, 4]) rpn_labels = tf.to_int32(rpn_labels, name="to_int32") rpn_labels = tf.reshape(rpn_labels, [-1]) self.add_anchor_img_smry(input_img_batch, anchors, rpn_labels) # --------------------------------------add smry---------------------------------------------------------- rpn_cls_category = tf.argmax(rpn_cls_prob, axis=1) kept_rpppn = tf.reshape(tf.where(tf.not_equal(rpn_labels, -1)), [-1]) rpn_cls_category = tf.gather(rpn_cls_category, kept_rpppn) acc = tf.reduce_mean( tf.to_float( tf.equal(rpn_cls_category, tf.to_int64(tf.gather(rpn_labels, kept_rpppn))))) tf.summary.scalar('ACC/rpn_accuracy', acc) with tf.control_dependencies([rpn_labels]): with tf.variable_scope('sample_RFCN_minibatch'): rois, labels, bbox_targets = \ tf.py_func(proposal_target_layer, [rois, gtboxes_batch], [tf.float32, tf.float32, tf.float32]) rois = tf.reshape(rois, [-1, 4]) labels = tf.to_int32(labels) labels = tf.reshape(labels, [-1]) bbox_targets = tf.reshape(bbox_targets, [-1, 4 * (cfgs.CLASS_NUM + 1)]) self.add_roi_batch_img_smry(input_img_batch, rois, labels) # -------------------------------------------------------------------------------------------------------------# # RFCN # # -------------------------------------------------------------------------------------------------------------# # 5. build rfcn head bbox_pred, cls_score = self.build_rfcn_head( rfcn_base=rfcn_base, rois=rois, img_shape=img_shape, bin_nums=[3, 3], crop_size=[9, 9]) # crop_size is the total size # bbox_pred shape: [-1, 4*(cls_num+1)]. # cls_score shape: [-1, cls_num+1] cls_prob = slim.softmax(cls_score, 'cls_prob') # ----------------------------------------------add smry------------------------------------------------------- if self.is_training: cls_category = tf.argmax(cls_prob, axis=1) rfcn_acc = tf.reduce_mean( tf.to_float(tf.equal(cls_category, tf.to_int64(labels)))) tf.summary.scalar('ACC/rfcn_acc', rfcn_acc) # 6. postprocess_rfcn if not self.is_training: return self.postprocess_rfcn(rois=rois, bbox_ppred=bbox_pred, scores=cls_prob, img_shape=img_shape) else: ''' when trian. We need build Loss ''' loss_dict = self.build_loss(rpn_box_pred=rpn_box_pred, rpn_bbox_targets=rpn_bbox_targets, rpn_cls_score=rpn_cls_score, rpn_labels=rpn_labels, bbox_pred=bbox_pred, bbox_targets=bbox_targets, cls_score=cls_score, labels=labels) final_bbox, final_scores, final_category = self.postprocess_rfcn( rois=rois, bbox_ppred=bbox_pred, scores=cls_prob, img_shape=img_shape) return final_bbox, final_scores, final_category, loss_dict