inception_v4_test.py 12.9 KB
Newer Older
Alex Kurakin's avatar
Alex Kurakin committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
"""Tests for slim.inception_v4."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import tensorflow as tf
21
from tensorflow.contrib import slim as contrib_slim
Alex Kurakin's avatar
Alex Kurakin committed
22
23
24
25
26
27
28
29
30
31

from nets import inception


class InceptionTest(tf.test.TestCase):

  def testBuildLogits(self):
    batch_size = 5
    height, width = 299, 299
    num_classes = 1000
32
    inputs = tf.random.uniform((batch_size, height, width, 3))
Alex Kurakin's avatar
Alex Kurakin committed
33
34
35
36
37
38
39
40
41
42
43
44
45
46
    logits, end_points = inception.inception_v4(inputs, num_classes)
    auxlogits = end_points['AuxLogits']
    predictions = end_points['Predictions']
    self.assertTrue(auxlogits.op.name.startswith('InceptionV4/AuxLogits'))
    self.assertListEqual(auxlogits.get_shape().as_list(),
                         [batch_size, num_classes])
    self.assertTrue(logits.op.name.startswith('InceptionV4/Logits'))
    self.assertListEqual(logits.get_shape().as_list(),
                         [batch_size, num_classes])
    self.assertTrue(predictions.op.name.startswith(
        'InceptionV4/Logits/Predictions'))
    self.assertListEqual(predictions.get_shape().as_list(),
                         [batch_size, num_classes])

47
48
49
50
  def testBuildPreLogitsNetwork(self):
    batch_size = 5
    height, width = 299, 299
    num_classes = None
51
    inputs = tf.random.uniform((batch_size, height, width, 3))
52
53
54
55
56
57
    net, end_points = inception.inception_v4(inputs, num_classes)
    self.assertTrue(net.op.name.startswith('InceptionV4/Logits/AvgPool'))
    self.assertListEqual(net.get_shape().as_list(), [batch_size, 1, 1, 1536])
    self.assertFalse('Logits' in end_points)
    self.assertFalse('Predictions' in end_points)

Alex Kurakin's avatar
Alex Kurakin committed
58
59
60
61
  def testBuildWithoutAuxLogits(self):
    batch_size = 5
    height, width = 299, 299
    num_classes = 1000
62
    inputs = tf.random.uniform((batch_size, height, width, 3))
Alex Kurakin's avatar
Alex Kurakin committed
63
64
65
66
67
68
69
70
71
72
73
    logits, endpoints = inception.inception_v4(inputs, num_classes,
                                               create_aux_logits=False)
    self.assertFalse('AuxLogits' in endpoints)
    self.assertTrue(logits.op.name.startswith('InceptionV4/Logits'))
    self.assertListEqual(logits.get_shape().as_list(),
                         [batch_size, num_classes])

  def testAllEndPointsShapes(self):
    batch_size = 5
    height, width = 299, 299
    num_classes = 1000
74
    inputs = tf.random.uniform((batch_size, height, width, 3))
Alex Kurakin's avatar
Alex Kurakin committed
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
    _, end_points = inception.inception_v4(inputs, num_classes)
    endpoints_shapes = {'Conv2d_1a_3x3': [batch_size, 149, 149, 32],
                        'Conv2d_2a_3x3': [batch_size, 147, 147, 32],
                        'Conv2d_2b_3x3': [batch_size, 147, 147, 64],
                        'Mixed_3a': [batch_size, 73, 73, 160],
                        'Mixed_4a': [batch_size, 71, 71, 192],
                        'Mixed_5a': [batch_size, 35, 35, 384],
                        # 4 x Inception-A blocks
                        'Mixed_5b': [batch_size, 35, 35, 384],
                        'Mixed_5c': [batch_size, 35, 35, 384],
                        'Mixed_5d': [batch_size, 35, 35, 384],
                        'Mixed_5e': [batch_size, 35, 35, 384],
                        # Reduction-A block
                        'Mixed_6a': [batch_size, 17, 17, 1024],
                        # 7 x Inception-B blocks
                        'Mixed_6b': [batch_size, 17, 17, 1024],
                        'Mixed_6c': [batch_size, 17, 17, 1024],
                        'Mixed_6d': [batch_size, 17, 17, 1024],
                        'Mixed_6e': [batch_size, 17, 17, 1024],
                        'Mixed_6f': [batch_size, 17, 17, 1024],
                        'Mixed_6g': [batch_size, 17, 17, 1024],
                        'Mixed_6h': [batch_size, 17, 17, 1024],
                        # Reduction-A block
                        'Mixed_7a': [batch_size, 8, 8, 1536],
                        # 3 x Inception-C blocks
                        'Mixed_7b': [batch_size, 8, 8, 1536],
                        'Mixed_7c': [batch_size, 8, 8, 1536],
                        'Mixed_7d': [batch_size, 8, 8, 1536],
                        # Logits and predictions
                        'AuxLogits': [batch_size, num_classes],
105
                        'global_pool': [batch_size, 1, 1, 1536],
Alex Kurakin's avatar
Alex Kurakin committed
106
107
108
109
110
111
112
113
114
115
116
117
118
                        'PreLogitsFlatten': [batch_size, 1536],
                        'Logits': [batch_size, num_classes],
                        'Predictions': [batch_size, num_classes]}
    self.assertItemsEqual(endpoints_shapes.keys(), end_points.keys())
    for endpoint_name in endpoints_shapes:
      expected_shape = endpoints_shapes[endpoint_name]
      self.assertTrue(endpoint_name in end_points)
      self.assertListEqual(end_points[endpoint_name].get_shape().as_list(),
                           expected_shape)

  def testBuildBaseNetwork(self):
    batch_size = 5
    height, width = 299, 299
119
    inputs = tf.random.uniform((batch_size, height, width, 3))
Alex Kurakin's avatar
Alex Kurakin committed
120
121
122
123
124
125
126
127
128
129
130
    net, end_points = inception.inception_v4_base(inputs)
    self.assertTrue(net.op.name.startswith(
        'InceptionV4/Mixed_7d'))
    self.assertListEqual(net.get_shape().as_list(), [batch_size, 8, 8, 1536])
    expected_endpoints = [
        'Conv2d_1a_3x3', 'Conv2d_2a_3x3', 'Conv2d_2b_3x3', 'Mixed_3a',
        'Mixed_4a', 'Mixed_5a', 'Mixed_5b', 'Mixed_5c', 'Mixed_5d',
        'Mixed_5e', 'Mixed_6a', 'Mixed_6b', 'Mixed_6c', 'Mixed_6d',
        'Mixed_6e', 'Mixed_6f', 'Mixed_6g', 'Mixed_6h', 'Mixed_7a',
        'Mixed_7b', 'Mixed_7c', 'Mixed_7d']
    self.assertItemsEqual(end_points.keys(), expected_endpoints)
Mark Sandler's avatar
Mark Sandler committed
131
    for name, op in end_points.items():
Alex Kurakin's avatar
Alex Kurakin committed
132
133
134
135
136
137
138
139
140
141
142
143
144
      self.assertTrue(op.name.startswith('InceptionV4/' + name))

  def testBuildOnlyUpToFinalEndpoint(self):
    batch_size = 5
    height, width = 299, 299
    all_endpoints = [
        'Conv2d_1a_3x3', 'Conv2d_2a_3x3', 'Conv2d_2b_3x3', 'Mixed_3a',
        'Mixed_4a', 'Mixed_5a', 'Mixed_5b', 'Mixed_5c', 'Mixed_5d',
        'Mixed_5e', 'Mixed_6a', 'Mixed_6b', 'Mixed_6c', 'Mixed_6d',
        'Mixed_6e', 'Mixed_6f', 'Mixed_6g', 'Mixed_6h', 'Mixed_7a',
        'Mixed_7b', 'Mixed_7c', 'Mixed_7d']
    for index, endpoint in enumerate(all_endpoints):
      with tf.Graph().as_default():
145
        inputs = tf.random.uniform((batch_size, height, width, 3))
Alex Kurakin's avatar
Alex Kurakin committed
146
147
148
149
        out_tensor, end_points = inception.inception_v4_base(
            inputs, final_endpoint=endpoint)
        self.assertTrue(out_tensor.op.name.startswith(
            'InceptionV4/' + endpoint))
pkulzc's avatar
pkulzc committed
150
        self.assertItemsEqual(all_endpoints[:index+1], end_points.keys())
Alex Kurakin's avatar
Alex Kurakin committed
151
152
153
154
155

  def testVariablesSetDevice(self):
    batch_size = 5
    height, width = 299, 299
    num_classes = 1000
156
    inputs = tf.random.uniform((batch_size, height, width, 3))
Alex Kurakin's avatar
Alex Kurakin committed
157
    # Force all Variables to reside on the device.
158
    with tf.compat.v1.variable_scope('on_cpu'), tf.device('/cpu:0'):
Alex Kurakin's avatar
Alex Kurakin committed
159
      inception.inception_v4(inputs, num_classes)
160
    with tf.compat.v1.variable_scope('on_gpu'), tf.device('/gpu:0'):
Alex Kurakin's avatar
Alex Kurakin committed
161
      inception.inception_v4(inputs, num_classes)
162
163
    for v in tf.compat.v1.get_collection(
        tf.compat.v1.GraphKeys.GLOBAL_VARIABLES, scope='on_cpu'):
Alex Kurakin's avatar
Alex Kurakin committed
164
      self.assertDeviceEqual(v.device, '/cpu:0')
165
166
    for v in tf.compat.v1.get_collection(
        tf.compat.v1.GraphKeys.GLOBAL_VARIABLES, scope='on_gpu'):
Alex Kurakin's avatar
Alex Kurakin committed
167
168
169
170
171
172
      self.assertDeviceEqual(v.device, '/gpu:0')

  def testHalfSizeImages(self):
    batch_size = 5
    height, width = 150, 150
    num_classes = 1000
173
    inputs = tf.random.uniform((batch_size, height, width, 3))
Alex Kurakin's avatar
Alex Kurakin committed
174
175
176
177
178
179
180
181
    logits, end_points = inception.inception_v4(inputs, num_classes)
    self.assertTrue(logits.op.name.startswith('InceptionV4/Logits'))
    self.assertListEqual(logits.get_shape().as_list(),
                         [batch_size, num_classes])
    pre_pool = end_points['Mixed_7d']
    self.assertListEqual(pre_pool.get_shape().as_list(),
                         [batch_size, 3, 3, 1536])

182
  def testGlobalPool(self):
pkulzc's avatar
pkulzc committed
183
184
    batch_size = 1
    height, width = 350, 400
185
    num_classes = 1000
186
    inputs = tf.random.uniform((batch_size, height, width, 3))
187
188
189
190
191
192
    logits, end_points = inception.inception_v4(inputs, num_classes)
    self.assertTrue(logits.op.name.startswith('InceptionV4/Logits'))
    self.assertListEqual(logits.get_shape().as_list(),
                         [batch_size, num_classes])
    pre_pool = end_points['Mixed_7d']
    self.assertListEqual(pre_pool.get_shape().as_list(),
pkulzc's avatar
pkulzc committed
193
                         [batch_size, 9, 11, 1536])
194
195

  def testGlobalPoolUnknownImageShape(self):
pkulzc's avatar
pkulzc committed
196
197
    batch_size = 1
    height, width = 350, 400
198
199
    num_classes = 1000
    with self.test_session() as sess:
200
      inputs = tf.compat.v1.placeholder(tf.float32, (batch_size, None, None, 3))
201
202
203
204
205
206
      logits, end_points = inception.inception_v4(
          inputs, num_classes, create_aux_logits=False)
      self.assertTrue(logits.op.name.startswith('InceptionV4/Logits'))
      self.assertListEqual(logits.get_shape().as_list(),
                           [batch_size, num_classes])
      pre_pool = end_points['Mixed_7d']
207
208
      images = tf.random.uniform((batch_size, height, width, 3))
      sess.run(tf.compat.v1.global_variables_initializer())
209
210
211
      logits_out, pre_pool_out = sess.run([logits, pre_pool],
                                          {inputs: images.eval()})
      self.assertTupleEqual(logits_out.shape, (batch_size, num_classes))
pkulzc's avatar
pkulzc committed
212
      self.assertTupleEqual(pre_pool_out.shape, (batch_size, 9, 11, 1536))
213

Alex Kurakin's avatar
Alex Kurakin committed
214
215
216
217
218
  def testUnknownBatchSize(self):
    batch_size = 1
    height, width = 299, 299
    num_classes = 1000
    with self.test_session() as sess:
219
      inputs = tf.compat.v1.placeholder(tf.float32, (None, height, width, 3))
Alex Kurakin's avatar
Alex Kurakin committed
220
221
222
223
      logits, _ = inception.inception_v4(inputs, num_classes)
      self.assertTrue(logits.op.name.startswith('InceptionV4/Logits'))
      self.assertListEqual(logits.get_shape().as_list(),
                           [None, num_classes])
224
225
      images = tf.random.uniform((batch_size, height, width, 3))
      sess.run(tf.compat.v1.global_variables_initializer())
Alex Kurakin's avatar
Alex Kurakin committed
226
227
228
229
230
231
232
233
      output = sess.run(logits, {inputs: images.eval()})
      self.assertEquals(output.shape, (batch_size, num_classes))

  def testEvaluation(self):
    batch_size = 2
    height, width = 299, 299
    num_classes = 1000
    with self.test_session() as sess:
234
      eval_inputs = tf.random.uniform((batch_size, height, width, 3))
Alex Kurakin's avatar
Alex Kurakin committed
235
236
237
      logits, _ = inception.inception_v4(eval_inputs,
                                         num_classes,
                                         is_training=False)
238
239
      predictions = tf.argmax(input=logits, axis=1)
      sess.run(tf.compat.v1.global_variables_initializer())
Alex Kurakin's avatar
Alex Kurakin committed
240
241
242
243
244
245
246
247
248
      output = sess.run(predictions)
      self.assertEquals(output.shape, (batch_size,))

  def testTrainEvalWithReuse(self):
    train_batch_size = 5
    eval_batch_size = 2
    height, width = 150, 150
    num_classes = 1000
    with self.test_session() as sess:
249
      train_inputs = tf.random.uniform((train_batch_size, height, width, 3))
Alex Kurakin's avatar
Alex Kurakin committed
250
      inception.inception_v4(train_inputs, num_classes)
251
      eval_inputs = tf.random.uniform((eval_batch_size, height, width, 3))
Alex Kurakin's avatar
Alex Kurakin committed
252
253
254
255
      logits, _ = inception.inception_v4(eval_inputs,
                                         num_classes,
                                         is_training=False,
                                         reuse=True)
256
257
      predictions = tf.argmax(input=logits, axis=1)
      sess.run(tf.compat.v1.global_variables_initializer())
Alex Kurakin's avatar
Alex Kurakin committed
258
259
260
      output = sess.run(predictions)
      self.assertEquals(output.shape, (eval_batch_size,))

261
262
263
  def testNoBatchNormScaleByDefault(self):
    height, width = 299, 299
    num_classes = 1000
264
    inputs = tf.compat.v1.placeholder(tf.float32, (1, height, width, 3))
265
    with contrib_slim.arg_scope(inception.inception_v4_arg_scope()):
266
267
      inception.inception_v4(inputs, num_classes, is_training=False)

268
    self.assertEqual(tf.compat.v1.global_variables('.*/BatchNorm/gamma:0$'), [])
269
270
271
272

  def testBatchNormScale(self):
    height, width = 299, 299
    num_classes = 1000
273
    inputs = tf.compat.v1.placeholder(tf.float32, (1, height, width, 3))
274
    with contrib_slim.arg_scope(
275
276
277
278
        inception.inception_v4_arg_scope(batch_norm_scale=True)):
      inception.inception_v4(inputs, num_classes, is_training=False)

    gamma_names = set(
279
280
        v.op.name
        for v in tf.compat.v1.global_variables('.*/BatchNorm/gamma:0$'))
281
    self.assertGreater(len(gamma_names), 0)
282
    for v in tf.compat.v1.global_variables('.*/BatchNorm/moving_mean:0$'):
283
284
      self.assertIn(v.op.name[:-len('moving_mean')] + 'gamma', gamma_names)

Alex Kurakin's avatar
Alex Kurakin committed
285
286
287

if __name__ == '__main__':
  tf.test.main()