def test_box_predictor_builder_calls_fc_argscope_fn(self):
     fc_hyperparams_text_proto = """
   regularizer {
     l1_regularizer {
       weight: 0.0003
     }
   }
   initializer {
     truncated_normal_initializer {
       mean: 0.0
       stddev: 0.3
     }
   }
   activation: RELU_6
   op: FC
 """
     hyperparams_proto = hyperparams_pb2.Hyperparams()
     text_format.Merge(fc_hyperparams_text_proto, hyperparams_proto)
     box_predictor_proto = box_predictor_pb2.BoxPredictor()
     box_predictor_proto.mask_rcnn_box_predictor.fc_hyperparams.CopyFrom(
         hyperparams_proto)
     mock_argscope_fn = mock.Mock(return_value='arg_scope')
     box_predictor = box_predictor_builder.build(
         argscope_fn=mock_argscope_fn,
         box_predictor_config=box_predictor_proto,
         is_training=False,
         num_classes=10)
     mock_argscope_fn.assert_called_with(hyperparams_proto, False)
     self.assertEqual(box_predictor._box_prediction_head._fc_hyperparams_fn,
                      'arg_scope')
     self.assertEqual(
         box_predictor._class_prediction_head._fc_hyperparams_fn,
         'arg_scope')
    def test_default_rfcn_box_predictor(self):
        conv_hyperparams_text_proto = """
      regularizer {
        l1_regularizer {
        }
      }
      initializer {
        truncated_normal_initializer {
        }
      }
      activation: RELU_6
    """
        hyperparams_proto = hyperparams_pb2.Hyperparams()
        text_format.Merge(conv_hyperparams_text_proto, hyperparams_proto)

        def mock_conv_argscope_builder(conv_hyperparams_arg, is_training):
            return (conv_hyperparams_arg, is_training)

        box_predictor_proto = box_predictor_pb2.BoxPredictor()
        box_predictor_proto.rfcn_box_predictor.conv_hyperparams.CopyFrom(
            hyperparams_proto)
        box_predictor = box_predictor_builder.build(
            argscope_fn=mock_conv_argscope_builder,
            box_predictor_config=box_predictor_proto,
            is_training=True,
            num_classes=90)
        self.assertEqual(box_predictor.num_classes, 90)
        self.assertTrue(box_predictor._is_training)
        self.assertEqual(box_predictor._box_code_size, 4)
        self.assertEqual(box_predictor._num_spatial_bins, [3, 3])
        self.assertEqual(box_predictor._crop_size, [12, 12])
 def test_construct_default_conv_box_predictor_with_batch_norm(self):
     box_predictor_text_proto = """
   weight_shared_convolutional_box_predictor {
     conv_hyperparams {
       regularizer {
         l1_regularizer {
         }
       }
       batch_norm {
         train: true
       }
       initializer {
         truncated_normal_initializer {
         }
       }
     }
   }"""
     box_predictor_proto = box_predictor_pb2.BoxPredictor()
     text_format.Merge(box_predictor_text_proto, box_predictor_proto)
     box_predictor = box_predictor_builder.build(
         argscope_fn=hyperparams_builder.build,
         box_predictor_config=box_predictor_proto,
         is_training=True,
         num_classes=90)
     self.assertEqual(box_predictor._depth, 0)
     self.assertEqual(box_predictor._num_layers_before_predictor, 0)
     self.assertEqual(box_predictor.num_classes, 90)
     self.assertTrue(box_predictor._is_training)
     self.assertEqual(box_predictor._apply_batch_norm, True)
 def test_construct_default_conv_box_predictor(self):
     box_predictor_text_proto = """
   convolutional_box_predictor {
     conv_hyperparams {
       regularizer {
         l1_regularizer {
         }
       }
       initializer {
         truncated_normal_initializer {
         }
       }
     }
   }"""
     box_predictor_proto = box_predictor_pb2.BoxPredictor()
     text_format.Merge(box_predictor_text_proto, box_predictor_proto)
     box_predictor = box_predictor_builder.build(
         argscope_fn=hyperparams_builder.build,
         box_predictor_config=box_predictor_proto,
         is_training=True,
         num_classes=90)
     self.assertEqual(box_predictor._min_depth, 0)
     self.assertEqual(box_predictor._max_depth, 0)
     self.assertEqual(box_predictor._num_layers_before_predictor, 0)
     self.assertTrue(box_predictor._use_dropout)
     self.assertAlmostEqual(box_predictor._dropout_keep_prob, 0.8)
     self.assertFalse(box_predictor._apply_sigmoid_to_scores)
     self.assertEqual(box_predictor.num_classes, 90)
     self.assertTrue(box_predictor._is_training)
     self.assertFalse(box_predictor._use_depthwise)
    def test_construct_non_default_conv_box_predictor(self):
        box_predictor_text_proto = """
      convolutional_box_predictor {
        min_depth: 2
        max_depth: 16
        num_layers_before_predictor: 2
        use_dropout: false
        dropout_keep_probability: 0.4
        kernel_size: 3
        box_code_size: 3
        apply_sigmoid_to_scores: true
        class_prediction_bias_init: 4.0
        use_depthwise: true
      }
    """
        conv_hyperparams_text_proto = """
      regularizer {
        l1_regularizer {
        }
      }
      initializer {
        truncated_normal_initializer {
        }
      }
    """
        hyperparams_proto = hyperparams_pb2.Hyperparams()
        text_format.Merge(conv_hyperparams_text_proto, hyperparams_proto)

        def mock_conv_argscope_builder(conv_hyperparams_arg, is_training):
            return (conv_hyperparams_arg, is_training)

        box_predictor_proto = box_predictor_pb2.BoxPredictor()
        text_format.Merge(box_predictor_text_proto, box_predictor_proto)
        box_predictor_proto.convolutional_box_predictor.conv_hyperparams.CopyFrom(
            hyperparams_proto)
        box_predictor = box_predictor_builder.build(
            argscope_fn=mock_conv_argscope_builder,
            box_predictor_config=box_predictor_proto,
            is_training=False,
            num_classes=10)
        self.assertEqual(box_predictor._min_depth, 2)
        self.assertEqual(box_predictor._max_depth, 16)
        self.assertEqual(box_predictor._num_layers_before_predictor, 2)
        self.assertFalse(box_predictor._use_dropout)
        self.assertAlmostEqual(box_predictor._dropout_keep_prob, 0.4)
        self.assertTrue(box_predictor._apply_sigmoid_to_scores)
        self.assertAlmostEqual(box_predictor._class_prediction_bias_init, 4.0)
        self.assertEqual(box_predictor.num_classes, 10)
        self.assertFalse(box_predictor._is_training)
        self.assertTrue(box_predictor._use_depthwise)
    def test_non_default_mask_rcnn_box_predictor(self):
        fc_hyperparams_text_proto = """
      regularizer {
        l1_regularizer {
        }
      }
      initializer {
        truncated_normal_initializer {
        }
      }
      activation: RELU_6
      op: FC
    """
        box_predictor_text_proto = """
      mask_rcnn_box_predictor {
        use_dropout: true
        dropout_keep_probability: 0.8
        box_code_size: 3
        share_box_across_classes: true
      }
    """
        hyperparams_proto = hyperparams_pb2.Hyperparams()
        text_format.Merge(fc_hyperparams_text_proto, hyperparams_proto)

        def mock_fc_argscope_builder(fc_hyperparams_arg, is_training):
            return (fc_hyperparams_arg, is_training)

        box_predictor_proto = box_predictor_pb2.BoxPredictor()
        text_format.Merge(box_predictor_text_proto, box_predictor_proto)
        box_predictor_proto.mask_rcnn_box_predictor.fc_hyperparams.CopyFrom(
            hyperparams_proto)
        box_predictor = box_predictor_builder.build(
            argscope_fn=mock_fc_argscope_builder,
            box_predictor_config=box_predictor_proto,
            is_training=True,
            num_classes=90)
        box_head = box_predictor._box_prediction_head
        class_head = box_predictor._class_prediction_head
        self.assertTrue(box_head._use_dropout)
        self.assertTrue(class_head._use_dropout)
        self.assertAlmostEqual(box_head._dropout_keep_prob, 0.8)
        self.assertAlmostEqual(class_head._dropout_keep_prob, 0.8)
        self.assertEqual(box_predictor.num_classes, 90)
        self.assertTrue(box_predictor._is_training)
        self.assertEqual(box_head._box_code_size, 3)
        self.assertEqual(box_head._share_box_across_classes, True)
    def test_box_predictor_calls_fc_argscope_fn(self):
        conv_hyperparams_text_proto = """
      regularizer {
        l1_regularizer {
          weight: 0.0003
        }
      }
      initializer {
        truncated_normal_initializer {
          mean: 0.0
          stddev: 0.3
        }
      }
      activation: RELU_6
    """
        hyperparams_proto = hyperparams_pb2.Hyperparams()
        text_format.Merge(conv_hyperparams_text_proto, hyperparams_proto)

        def mock_conv_argscope_builder(conv_hyperparams_arg, is_training):
            return (conv_hyperparams_arg, is_training)

        box_predictor_proto = box_predictor_pb2.BoxPredictor()
        box_predictor_proto.rfcn_box_predictor.conv_hyperparams.CopyFrom(
            hyperparams_proto)
        box_predictor = box_predictor_builder.build(
            argscope_fn=mock_conv_argscope_builder,
            box_predictor_config=box_predictor_proto,
            is_training=False,
            num_classes=10)
        (conv_hyperparams_actual,
         is_training) = box_predictor._conv_hyperparams_fn
        self.assertAlmostEqual(
            (hyperparams_proto.regularizer.l1_regularizer.weight),
            (conv_hyperparams_actual.regularizer.l1_regularizer.weight))
        self.assertAlmostEqual((
            hyperparams_proto.initializer.truncated_normal_initializer.stddev),
                               (conv_hyperparams_actual.initializer.
                                truncated_normal_initializer.stddev))
        self.assertAlmostEqual(
            (hyperparams_proto.initializer.truncated_normal_initializer.mean),
            (conv_hyperparams_actual.initializer.truncated_normal_initializer.
             mean))
        self.assertEqual(hyperparams_proto.activation,
                         conv_hyperparams_actual.activation)
        self.assertFalse(is_training)
 def test_build_default_mask_rcnn_box_predictor(self):
     box_predictor_proto = box_predictor_pb2.BoxPredictor()
     box_predictor_proto.mask_rcnn_box_predictor.fc_hyperparams.op = (
         hyperparams_pb2.Hyperparams.FC)
     box_predictor = box_predictor_builder.build(
         argscope_fn=mock.Mock(return_value='arg_scope'),
         box_predictor_config=box_predictor_proto,
         is_training=True,
         num_classes=90)
     box_head = box_predictor._box_prediction_head
     class_head = box_predictor._class_prediction_head
     self.assertFalse(box_head._use_dropout)
     self.assertFalse(class_head._use_dropout)
     self.assertAlmostEqual(box_head._dropout_keep_prob, 0.5)
     self.assertEqual(box_predictor.num_classes, 90)
     self.assertTrue(box_predictor._is_training)
     self.assertEqual(box_head._box_code_size, 4)
     self.assertEqual(len(box_predictor._third_stage_heads.keys()), 0)
    def test_construct_non_default_conv_box_predictor(self):
        box_predictor_text_proto = """
      weight_shared_convolutional_box_predictor {
        depth: 2
        num_layers_before_predictor: 2
        kernel_size: 7
        box_code_size: 3
        class_prediction_bias_init: 4.0
      }
    """
        conv_hyperparams_text_proto = """
      regularizer {
        l1_regularizer {
        }
      }
      initializer {
        truncated_normal_initializer {
        }
      }
    """
        hyperparams_proto = hyperparams_pb2.Hyperparams()
        text_format.Merge(conv_hyperparams_text_proto, hyperparams_proto)

        def mock_conv_argscope_builder(conv_hyperparams_arg, is_training):
            return (conv_hyperparams_arg, is_training)

        box_predictor_proto = box_predictor_pb2.BoxPredictor()
        text_format.Merge(box_predictor_text_proto, box_predictor_proto)
        (box_predictor_proto.weight_shared_convolutional_box_predictor.
         conv_hyperparams.CopyFrom(hyperparams_proto))
        box_predictor = box_predictor_builder.build(
            argscope_fn=mock_conv_argscope_builder,
            box_predictor_config=box_predictor_proto,
            is_training=False,
            num_classes=10)
        self.assertEqual(box_predictor._depth, 2)
        self.assertEqual(box_predictor._num_layers_before_predictor, 2)
        self.assertAlmostEqual(box_predictor._class_prediction_bias_init, 4.0)
        self.assertEqual(box_predictor.num_classes, 10)
        self.assertFalse(box_predictor._is_training)
        self.assertEqual(box_predictor._apply_batch_norm, False)
 def test_build_box_predictor_with_mask_branch(self):
     box_predictor_proto = box_predictor_pb2.BoxPredictor()
     box_predictor_proto.mask_rcnn_box_predictor.fc_hyperparams.op = (
         hyperparams_pb2.Hyperparams.FC)
     box_predictor_proto.mask_rcnn_box_predictor.conv_hyperparams.op = (
         hyperparams_pb2.Hyperparams.CONV)
     box_predictor_proto.mask_rcnn_box_predictor.predict_instance_masks = True
     box_predictor_proto.mask_rcnn_box_predictor.mask_prediction_conv_depth = 512
     box_predictor_proto.mask_rcnn_box_predictor.mask_height = 16
     box_predictor_proto.mask_rcnn_box_predictor.mask_width = 16
     mock_argscope_fn = mock.Mock(return_value='arg_scope')
     box_predictor = box_predictor_builder.build(
         argscope_fn=mock_argscope_fn,
         box_predictor_config=box_predictor_proto,
         is_training=True,
         num_classes=90)
     mock_argscope_fn.assert_has_calls([
         mock.call(
             box_predictor_proto.mask_rcnn_box_predictor.fc_hyperparams,
             True),
         mock.call(
             box_predictor_proto.mask_rcnn_box_predictor.conv_hyperparams,
             True)
     ],
                                       any_order=True)
     box_head = box_predictor._box_prediction_head
     class_head = box_predictor._class_prediction_head
     third_stage_heads = box_predictor._third_stage_heads
     self.assertFalse(box_head._use_dropout)
     self.assertFalse(class_head._use_dropout)
     self.assertAlmostEqual(box_head._dropout_keep_prob, 0.5)
     self.assertAlmostEqual(class_head._dropout_keep_prob, 0.5)
     self.assertEqual(box_predictor.num_classes, 90)
     self.assertTrue(box_predictor._is_training)
     self.assertEqual(box_head._box_code_size, 4)
     self.assertTrue(
         mask_rcnn_box_predictor.MASK_PREDICTIONS in third_stage_heads)
     self.assertEqual(
         third_stage_heads[mask_rcnn_box_predictor.MASK_PREDICTIONS].
         _mask_prediction_conv_depth, 512)
Exemplo n.º 11
0
def _build_faster_rcnn_model(frcnn_config, is_training, add_summaries):
    """Builds a Faster R-CNN or R-FCN detection model based on the model config.

  Builds R-FCN model if the second_stage_box_predictor in the config is of type
  `rfcn_box_predictor` else builds a Faster R-CNN model.

  Args:
    frcnn_config: A faster_rcnn.proto object containing the config for the
      desired FasterRCNNMetaArch or RFCNMetaArch.
    is_training: True if this model is being built for training purposes.
    add_summaries: Whether to add tf summaries in the model.

  Returns:
    FasterRCNNMetaArch based on the config.

  Raises:
    ValueError: If frcnn_config.type is not recognized (i.e. not registered in
      model_class_map).
  """
    num_classes = frcnn_config.num_classes
    image_resizer_fn = image_resizer_builder.build(frcnn_config.image_resizer)

    feature_extractor = _build_faster_rcnn_feature_extractor(
        frcnn_config.feature_extractor, is_training,
        frcnn_config.inplace_batchnorm_update)

    number_of_stages = frcnn_config.number_of_stages
    first_stage_anchor_generator = anchor_generator_builder.build(
        frcnn_config.first_stage_anchor_generator)

    first_stage_target_assigner = target_assigner.create_target_assigner(
        'FasterRCNN',
        'proposal',
        use_matmul_gather=frcnn_config.use_matmul_gather_in_matcher)
    first_stage_atrous_rate = frcnn_config.first_stage_atrous_rate
    first_stage_box_predictor_arg_scope_fn = hyperparams_builder.build(
        frcnn_config.first_stage_box_predictor_conv_hyperparams, is_training)
    first_stage_box_predictor_kernel_size = (
        frcnn_config.first_stage_box_predictor_kernel_size)
    first_stage_box_predictor_depth = frcnn_config.first_stage_box_predictor_depth
    first_stage_minibatch_size = frcnn_config.first_stage_minibatch_size
    first_stage_sampler = sampler.BalancedPositiveNegativeSampler(
        positive_fraction=frcnn_config.first_stage_positive_balance_fraction,
        is_static=frcnn_config.use_static_balanced_label_sampler)
    first_stage_nms_score_threshold = frcnn_config.first_stage_nms_score_threshold
    first_stage_nms_iou_threshold = frcnn_config.first_stage_nms_iou_threshold
    first_stage_max_proposals = frcnn_config.first_stage_max_proposals
    first_stage_loc_loss_weight = (
        frcnn_config.first_stage_localization_loss_weight)
    first_stage_obj_loss_weight = frcnn_config.first_stage_objectness_loss_weight

    initial_crop_size = frcnn_config.initial_crop_size
    maxpool_kernel_size = frcnn_config.maxpool_kernel_size
    maxpool_stride = frcnn_config.maxpool_stride

    second_stage_target_assigner = target_assigner.create_target_assigner(
        'FasterRCNN',
        'detection',
        use_matmul_gather=frcnn_config.use_matmul_gather_in_matcher)
    second_stage_box_predictor = box_predictor_builder.build(
        hyperparams_builder.build,
        frcnn_config.second_stage_box_predictor,
        is_training=is_training,
        num_classes=num_classes)
    second_stage_batch_size = frcnn_config.second_stage_batch_size
    second_stage_sampler = sampler.BalancedPositiveNegativeSampler(
        positive_fraction=frcnn_config.second_stage_balance_fraction,
        is_static=frcnn_config.use_static_balanced_label_sampler)
    (second_stage_non_max_suppression_fn,
     second_stage_score_conversion_fn) = post_processing_builder.build(
         frcnn_config.second_stage_post_processing)
    second_stage_localization_loss_weight = (
        frcnn_config.second_stage_localization_loss_weight)
    second_stage_classification_loss = (
        losses_builder.build_faster_rcnn_classification_loss(
            frcnn_config.second_stage_classification_loss))
    second_stage_classification_loss_weight = (
        frcnn_config.second_stage_classification_loss_weight)
    second_stage_mask_prediction_loss_weight = (
        frcnn_config.second_stage_mask_prediction_loss_weight)

    hard_example_miner = None
    if frcnn_config.HasField('hard_example_miner'):
        hard_example_miner = losses_builder.build_hard_example_miner(
            frcnn_config.hard_example_miner,
            second_stage_classification_loss_weight,
            second_stage_localization_loss_weight)

    use_matmul_crop_and_resize = (frcnn_config.use_matmul_crop_and_resize)
    clip_anchors_to_image = (frcnn_config.clip_anchors_to_image)

    common_kwargs = {
        'is_training': is_training,
        'num_classes': num_classes,
        'image_resizer_fn': image_resizer_fn,
        'feature_extractor': feature_extractor,
        'number_of_stages': number_of_stages,
        'first_stage_anchor_generator': first_stage_anchor_generator,
        'first_stage_target_assigner': first_stage_target_assigner,
        'first_stage_atrous_rate': first_stage_atrous_rate,
        'first_stage_box_predictor_arg_scope_fn':
        first_stage_box_predictor_arg_scope_fn,
        'first_stage_box_predictor_kernel_size':
        first_stage_box_predictor_kernel_size,
        'first_stage_box_predictor_depth': first_stage_box_predictor_depth,
        'first_stage_minibatch_size': first_stage_minibatch_size,
        'first_stage_sampler': first_stage_sampler,
        'first_stage_nms_score_threshold': first_stage_nms_score_threshold,
        'first_stage_nms_iou_threshold': first_stage_nms_iou_threshold,
        'first_stage_max_proposals': first_stage_max_proposals,
        'first_stage_localization_loss_weight': first_stage_loc_loss_weight,
        'first_stage_objectness_loss_weight': first_stage_obj_loss_weight,
        'second_stage_target_assigner': second_stage_target_assigner,
        'second_stage_batch_size': second_stage_batch_size,
        'second_stage_sampler': second_stage_sampler,
        'second_stage_non_max_suppression_fn':
        second_stage_non_max_suppression_fn,
        'second_stage_score_conversion_fn': second_stage_score_conversion_fn,
        'second_stage_localization_loss_weight':
        second_stage_localization_loss_weight,
        'second_stage_classification_loss': second_stage_classification_loss,
        'second_stage_classification_loss_weight':
        second_stage_classification_loss_weight,
        'hard_example_miner': hard_example_miner,
        'add_summaries': add_summaries,
        'use_matmul_crop_and_resize': use_matmul_crop_and_resize,
        'clip_anchors_to_image': clip_anchors_to_image
    }

    if isinstance(second_stage_box_predictor,
                  rfcn_box_predictor.RfcnBoxPredictor):
        return rfcn_meta_arch.RFCNMetaArch(
            second_stage_rfcn_box_predictor=second_stage_box_predictor,
            **common_kwargs)
    else:
        return faster_rcnn_meta_arch.FasterRCNNMetaArch(
            initial_crop_size=initial_crop_size,
            maxpool_kernel_size=maxpool_kernel_size,
            maxpool_stride=maxpool_stride,
            second_stage_mask_rcnn_box_predictor=second_stage_box_predictor,
            second_stage_mask_prediction_loss_weight=(
                second_stage_mask_prediction_loss_weight),
            **common_kwargs)
Exemplo n.º 12
0
def _build_ssd_model(ssd_config,
                     is_training,
                     add_summaries,
                     add_background_class=True):
    """Builds an SSD detection model based on the model config.

  Args:
    ssd_config: A ssd.proto object containing the config for the desired
      SSDMetaArch.
    is_training: True if this model is being built for training purposes.
    add_summaries: Whether to add tf summaries in the model.
    add_background_class: Whether to add an implicit background class to one-hot
      encodings of groundtruth labels. Set to false if using groundtruth labels
      with an explicit background class or using multiclass scores instead of
      truth in the case of distillation.
  Returns:
    SSDMetaArch based on the config.

  Raises:
    ValueError: If ssd_config.type is not recognized (i.e. not registered in
      model_class_map).
  """
    num_classes = ssd_config.num_classes

    # Feature extractor
    feature_extractor = _build_ssd_feature_extractor(
        feature_extractor_config=ssd_config.feature_extractor,
        is_training=is_training)

    box_coder = box_coder_builder.build(ssd_config.box_coder)
    matcher = matcher_builder.build(ssd_config.matcher)
    region_similarity_calculator = sim_calc.build(
        ssd_config.similarity_calculator)
    encode_background_as_zeros = ssd_config.encode_background_as_zeros
    negative_class_weight = ssd_config.negative_class_weight
    ssd_box_predictor = box_predictor_builder.build(hyperparams_builder.build,
                                                    ssd_config.box_predictor,
                                                    is_training, num_classes)
    anchor_generator = anchor_generator_builder.build(
        ssd_config.anchor_generator)
    image_resizer_fn = image_resizer_builder.build(ssd_config.image_resizer)
    non_max_suppression_fn, score_conversion_fn = post_processing_builder.build(
        ssd_config.post_processing)
    (classification_loss, localization_loss, classification_weight,
     localization_weight, hard_example_miner,
     random_example_sampler) = losses_builder.build(ssd_config.loss)
    normalize_loss_by_num_matches = ssd_config.normalize_loss_by_num_matches
    normalize_loc_loss_by_codesize = ssd_config.normalize_loc_loss_by_codesize

    return ssd_meta_arch.SSDMetaArch(
        is_training,
        anchor_generator,
        ssd_box_predictor,
        box_coder,
        feature_extractor,
        matcher,
        region_similarity_calculator,
        encode_background_as_zeros,
        negative_class_weight,
        image_resizer_fn,
        non_max_suppression_fn,
        score_conversion_fn,
        classification_loss,
        localization_loss,
        classification_weight,
        localization_weight,
        normalize_loss_by_num_matches,
        hard_example_miner,
        add_summaries=add_summaries,
        normalize_loc_loss_by_codesize=normalize_loc_loss_by_codesize,
        freeze_batchnorm=ssd_config.freeze_batchnorm,
        inplace_batchnorm_update=ssd_config.inplace_batchnorm_update,
        add_background_class=add_background_class,
        random_example_sampler=random_example_sampler)