def testNoBatchNormScaleByDefault(self):
        height, width = 299, 299
        num_classes = 1000
        inputs = tf.placeholder(tf.float32, (1, height, width, 3))
        with slim.arg_scope(inception.inception_v3_arg_scope()):
            inception.inception_v3(inputs, num_classes, is_training=False)

        self.assertEqual(tf.global_variables('.*/BatchNorm/gamma:0$'), [])
    def testBatchNormScale(self):
        height, width = 299, 299
        num_classes = 1000
        inputs = tf.placeholder(tf.float32, (1, height, width, 3))
        with slim.arg_scope(
                inception.inception_v3_arg_scope(batch_norm_scale=True)):
            inception.inception_v3(inputs, num_classes, is_training=False)

        gamma_names = set(
            v.op.name for v in tf.global_variables('.*/BatchNorm/gamma:0$'))
        self.assertGreater(len(gamma_names), 0)
        for v in tf.global_variables('.*/BatchNorm/moving_mean:0$'):
            self.assertIn(v.op.name[:-len('moving_mean')] + 'gamma',
                          gamma_names)
    def testRaiseValueErrorWithInvalidDepthMultiplier(self):
        batch_size = 5
        height, width = 299, 299
        num_classes = 1000

        inputs = tf.random_uniform((batch_size, height, width, 3))
        with self.assertRaises(ValueError):
            _ = inception.inception_v3(inputs,
                                       num_classes,
                                       depth_multiplier=-0.1)
        with self.assertRaises(ValueError):
            _ = inception.inception_v3(inputs,
                                       num_classes,
                                       depth_multiplier=0.0)
    def testTrainEvalWithReuse(self):
        train_batch_size = 5
        eval_batch_size = 2
        height, width = 150, 150
        num_classes = 1000

        train_inputs = tf.random_uniform((train_batch_size, height, width, 3))
        inception.inception_v3(train_inputs, num_classes)
        eval_inputs = tf.random_uniform((eval_batch_size, height, width, 3))
        logits, _ = inception.inception_v3(eval_inputs,
                                           num_classes,
                                           is_training=False,
                                           reuse=True)
        predictions = tf.argmax(logits, 1)

        with self.test_session() as sess:
            sess.run(tf.global_variables_initializer())
            output = sess.run(predictions)
            self.assertEqual(output.shape, (eval_batch_size, ))
    def testBuildPreLogitsNetwork(self):
        batch_size = 5
        height, width = 299, 299
        num_classes = None

        inputs = tf.random_uniform((batch_size, height, width, 3))
        net, end_points = inception.inception_v3(inputs, num_classes)
        self.assertTrue(net.op.name.startswith('InceptionV3/Logits/AvgPool'))
        self.assertListEqual(net.get_shape().as_list(),
                             [batch_size, 1, 1, 2048])
        self.assertFalse('Logits' in end_points)
        self.assertFalse('Predictions' in end_points)
    def testLogitsNotSqueezed(self):
        num_classes = 25
        images = tf.random_uniform([1, 299, 299, 3])
        logits, _ = inception.inception_v3(images,
                                           num_classes=num_classes,
                                           spatial_squeeze=False)

        with self.test_session() as sess:
            tf.global_variables_initializer().run()
            logits_out = sess.run(logits)
            self.assertListEqual(list(logits_out.shape),
                                 [1, 1, 1, num_classes])
    def testHalfSizeImages(self):
        batch_size = 5
        height, width = 150, 150
        num_classes = 1000

        inputs = tf.random_uniform((batch_size, height, width, 3))
        logits, end_points = inception.inception_v3(inputs, num_classes)
        self.assertTrue(logits.op.name.startswith('InceptionV3/Logits'))
        self.assertListEqual(logits.get_shape().as_list(),
                             [batch_size, num_classes])
        pre_pool = end_points['Mixed_7c']
        self.assertListEqual(pre_pool.get_shape().as_list(),
                             [batch_size, 3, 3, 2048])
    def testBuildClassificationNetwork(self):
        batch_size = 5
        height, width = 299, 299
        num_classes = 1000

        inputs = tf.random_uniform((batch_size, height, width, 3))
        logits, end_points = inception.inception_v3(inputs, num_classes)
        self.assertTrue(
            logits.op.name.startswith('InceptionV3/Logits/SpatialSqueeze'))
        self.assertListEqual(logits.get_shape().as_list(),
                             [batch_size, num_classes])
        self.assertTrue('Predictions' in end_points)
        self.assertListEqual(end_points['Predictions'].get_shape().as_list(),
                             [batch_size, num_classes])
    def testEvaluation(self):
        batch_size = 2
        height, width = 299, 299
        num_classes = 1000

        eval_inputs = tf.random_uniform((batch_size, height, width, 3))
        logits, _ = inception.inception_v3(eval_inputs,
                                           num_classes,
                                           is_training=False)
        predictions = tf.argmax(logits, 1)

        with self.test_session() as sess:
            sess.run(tf.global_variables_initializer())
            output = sess.run(predictions)
            self.assertEqual(output.shape, (batch_size, ))
    def testUnknowBatchSize(self):
        batch_size = 1
        height, width = 299, 299
        num_classes = 1000

        inputs = tf.placeholder(tf.float32, (None, height, width, 3))
        logits, _ = inception.inception_v3(inputs, num_classes)
        self.assertTrue(logits.op.name.startswith('InceptionV3/Logits'))
        self.assertListEqual(logits.get_shape().as_list(), [None, num_classes])
        images = tf.random_uniform((batch_size, height, width, 3))

        with self.test_session() as sess:
            sess.run(tf.global_variables_initializer())
            output = sess.run(logits, {inputs: images.eval()})
            self.assertEqual(output.shape, (batch_size, num_classes))
    def testBuildEndPointsWithDepthMultiplierGreaterThanOne(self):
        batch_size = 5
        height, width = 299, 299
        num_classes = 1000

        inputs = tf.random_uniform((batch_size, height, width, 3))
        _, end_points = inception.inception_v3(inputs, num_classes)

        endpoint_keys = [
            key for key in list(end_points.keys())
            if key.startswith('Mixed') or key.startswith('Conv')
        ]

        _, end_points_with_multiplier = inception.inception_v3(
            inputs,
            num_classes,
            scope='depth_multiplied_net',
            depth_multiplier=2.0)

        for key in endpoint_keys:
            original_depth = end_points[key].get_shape().as_list()[3]
            new_depth = end_points_with_multiplier[key].get_shape().as_list(
            )[3]
            self.assertEqual(2.0 * original_depth, new_depth)
 def testUnknownImageShape(self):
     tf.reset_default_graph()
     batch_size = 2
     height, width = 299, 299
     num_classes = 1000
     input_np = np.random.uniform(0, 1, (batch_size, height, width, 3))
     with self.test_session() as sess:
         inputs = tf.placeholder(tf.float32,
                                 shape=(batch_size, None, None, 3))
         logits, end_points = inception.inception_v3(inputs, num_classes)
         self.assertListEqual(logits.get_shape().as_list(),
                              [batch_size, num_classes])
         pre_pool = end_points['Mixed_7c']
         feed_dict = {inputs: input_np}
         tf.global_variables_initializer().run()
         pre_pool_out = sess.run(pre_pool, feed_dict=feed_dict)
         self.assertListEqual(list(pre_pool_out.shape),
                              [batch_size, 8, 8, 2048])
    def testBuildEndPoints(self):
        batch_size = 5
        height, width = 299, 299
        num_classes = 1000

        inputs = tf.random_uniform((batch_size, height, width, 3))
        _, end_points = inception.inception_v3(inputs, num_classes)
        self.assertTrue('Logits' in end_points)
        logits = end_points['Logits']
        self.assertListEqual(logits.get_shape().as_list(),
                             [batch_size, num_classes])
        self.assertTrue('AuxLogits' in end_points)
        aux_logits = end_points['AuxLogits']
        self.assertListEqual(aux_logits.get_shape().as_list(),
                             [batch_size, num_classes])
        self.assertTrue('Mixed_7c' in end_points)
        pre_pool = end_points['Mixed_7c']
        self.assertListEqual(pre_pool.get_shape().as_list(),
                             [batch_size, 8, 8, 2048])
        self.assertTrue('PreLogits' in end_points)
        pre_logits = end_points['PreLogits']
        self.assertListEqual(pre_logits.get_shape().as_list(),
                             [batch_size, 1, 1, 2048])