예제 #1
0
    def testTrainEvalWithReuse(self):
        train_batch_size = 5
        eval_batch_size = 2
        height, width = 224, 224
        num_classes = 1000

        train_inputs = random_ops.random_uniform(
            (train_batch_size, height, width, 3))
        inception_v1.inception_v1(train_inputs, num_classes)
        eval_inputs = random_ops.random_uniform(
            (eval_batch_size, height, width, 3))
        logits, _ = inception_v1.inception_v1(eval_inputs,
                                              num_classes,
                                              reuse=True)
        predictions = math_ops.argmax(logits, 1)

        with self.cached_session() as sess:
            sess.run(variables.global_variables_initializer())
            output = sess.run(predictions)
            self.assertEqual(output.shape, (eval_batch_size, ))
예제 #2
0
    def testLogitsNotSqueezed(self):
        num_classes = 25
        images = random_ops.random_uniform([1, 224, 224, 3])
        logits, _ = inception_v1.inception_v1(images,
                                              num_classes=num_classes,
                                              spatial_squeeze=False)

        with self.cached_session() as sess:
            variables.global_variables_initializer().run()
            logits_out = sess.run(logits)
            self.assertListEqual(list(logits_out.shape),
                                 [1, 1, 1, num_classes])
예제 #3
0
    def testBuildClassificationNetwork(self):
        batch_size = 5
        height, width = 224, 224
        num_classes = 1000

        inputs = random_ops.random_uniform((batch_size, height, width, 3))
        logits, end_points = inception_v1.inception_v1(inputs, num_classes)
        self.assertTrue(logits.op.name.startswith('InceptionV1/Logits'))
        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])
예제 #4
0
    def testEvaluation(self):
        batch_size = 2
        height, width = 224, 224
        num_classes = 1000

        eval_inputs = random_ops.random_uniform((batch_size, height, width, 3))
        logits, _ = inception_v1.inception_v1(eval_inputs,
                                              num_classes,
                                              is_training=False)
        predictions = math_ops.argmax(logits, 1)

        with self.cached_session() as sess:
            sess.run(variables.global_variables_initializer())
            output = sess.run(predictions)
            self.assertEqual(output.shape, (batch_size, ))
예제 #5
0
    def testUnknownBatchSize(self):
        batch_size = 1
        height, width = 224, 224
        num_classes = 1000

        inputs = array_ops.placeholder(dtypes.float32,
                                       (None, height, width, 3))
        logits, _ = inception_v1.inception_v1(inputs, num_classes)
        self.assertTrue(logits.op.name.startswith('InceptionV1/Logits'))
        self.assertListEqual(logits.get_shape().as_list(), [None, num_classes])
        images = random_ops.random_uniform((batch_size, height, width, 3))

        with self.cached_session() as sess:
            sess.run(variables.global_variables_initializer())
            output = sess.run(logits, {inputs: images.eval()})
            self.assertEqual(output.shape, (batch_size, num_classes))
예제 #6
0
 def testUnknownImageShape(self):
     ops.reset_default_graph()
     batch_size = 2
     height, width = 224, 224
     num_classes = 1000
     input_np = np.random.uniform(0, 1, (batch_size, height, width, 3))
     with self.cached_session() as sess:
         inputs = array_ops.placeholder(dtypes.float32,
                                        shape=(batch_size, None, None, 3))
         logits, end_points = inception_v1.inception_v1(inputs, num_classes)
         self.assertTrue(logits.op.name.startswith('InceptionV1/Logits'))
         self.assertListEqual(logits.get_shape().as_list(),
                              [batch_size, num_classes])
         pre_pool = end_points['Mixed_5c']
         feed_dict = {inputs: input_np}
         variables.global_variables_initializer().run()
         pre_pool_out = sess.run(pre_pool, feed_dict=feed_dict)
         self.assertListEqual(list(pre_pool_out.shape),
                              [batch_size, 7, 7, 1024])