Beispiel #1
0
    def test_serialize_deserialize(self, model_id):
        # Create a network object that sets all of its config options.
        kwargs = dict(
            model_id=model_id,
            filter_size_scale=1.0,
            use_sync_bn=False,
            kernel_initializer='VarianceScaling',
            kernel_regularizer=None,
            bias_regularizer=None,
            norm_momentum=0.99,
            norm_epsilon=0.001,
            min_depth=8,
            divisible_by=8,
            regularize_depthwise=False,
        )
        network = mobiledet.MobileDet(**kwargs)

        expected_config = dict(kwargs)
        self.assertEqual(network.get_config(), expected_config)

        # Create another network object from the first object's config.
        new_network = mobiledet.MobileDet.from_config(network.get_config())

        # Validate that the config can be forced to JSON.
        _ = new_network.to_json()

        # If the serialization was successful, the new config should match the old.
        self.assertAllEqual(network.get_config(), new_network.get_config())
Beispiel #2
0
    def test_input_specs(self, input_dim, model_id):
        """Test different input feature dimensions."""
        tf.keras.backend.set_image_data_format('channels_last')

        input_specs = tf.keras.layers.InputSpec(
            shape=[None, None, None, input_dim])
        network = mobiledet.MobileDet(model_id=model_id,
                                      input_specs=input_specs)

        inputs = tf.keras.Input(shape=(128, 128, input_dim), batch_size=1)
        _ = network(inputs)
Beispiel #3
0
    def test_mobiledet_creation(self, model_id, input_size):
        """Test creation of MobileDet family models."""
        tf.keras.backend.set_image_data_format('channels_last')

        mobiledet_layers = {
            # The number of filters of layers having outputs been collected
            # for filter_size_scale = 1.0
            'MobileDetCPU': [8, 16, 32, 72, 144],
            'MobileDetDSP': [24, 32, 64, 144, 240],
            'MobileDetEdgeTPU': [16, 16, 40, 96, 384],
            'MobileDetGPU': [16, 32, 64, 128, 384],
        }

        network = mobiledet.MobileDet(model_id=model_id, filter_size_scale=1.0)

        inputs = tf.keras.Input(shape=(input_size, input_size, 3),
                                batch_size=1)
        endpoints = network(inputs)

        for idx, num_filter in enumerate(mobiledet_layers[model_id]):
            self.assertAllEqual([
                1, input_size / 2**(idx + 1), input_size / 2**(idx + 1),
                num_filter
            ], endpoints[str(idx + 1)].shape.as_list())