imagenet_main.py 11.3 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# Copyright 2017 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.
# ==============================================================================
15
"""Runs a ResNet model on the ImageNet dataset."""
16
17
18
19
20
21
22

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import os

23
24
from absl import app as absl_app
from absl import flags
Karmel Allison's avatar
Karmel Allison committed
25
import tensorflow as tf  # pylint: disable=g-bad-import-order
26

27
from official.utils.flags import core as flags_core
28
from official.resnet import imagenet_preprocessing
29
30
from official.resnet import resnet_model
from official.resnet import resnet_run_loop
31

32
_DEFAULT_IMAGE_SIZE = 224
33
_NUM_CHANNELS = 3
34
_NUM_CLASSES = 1001
35

36
37
38
39
_NUM_IMAGES = {
    'train': 1281167,
    'validation': 50000,
}
40

41
_NUM_TRAIN_FILES = 1024
42
_SHUFFLE_BUFFER = 1500
43

44

45
46
47
###############################################################################
# Data processing
###############################################################################
48
def get_filenames(is_training, data_dir):
49
50
51
  """Return filenames for dataset."""
  if is_training:
    return [
52
        os.path.join(data_dir, 'train-%05d-of-01024' % i)
53
        for i in range(_NUM_TRAIN_FILES)]
54
55
  else:
    return [
56
        os.path.join(data_dir, 'validation-%05d-of-00128' % i)
Neal Wu's avatar
Neal Wu committed
57
        for i in range(128)]
58
59


60
61
62
def _parse_example_proto(example_serialized):
  """Parses an Example proto containing a training example of an image.

63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
  The output of the build_image_data.py image preprocessing script is a dataset
  containing serialized Example protocol buffers. Each Example proto contains
  the following fields (values are included as examples):

    image/height: 462
    image/width: 581
    image/colorspace: 'RGB'
    image/channels: 3
    image/class/label: 615
    image/class/synset: 'n03623198'
    image/class/text: 'knee pad'
    image/object/bbox/xmin: 0.1
    image/object/bbox/xmax: 0.9
    image/object/bbox/ymin: 0.2
    image/object/bbox/ymax: 0.6
    image/object/bbox/label: 615
    image/format: 'JPEG'
    image/filename: 'ILSVRC2012_val_00041207.JPEG'
    image/encoded: <JPEG encoded string>
82
83
84
85
86
87
88

  Args:
    example_serialized: scalar Tensor tf.string containing a serialized
      Example protocol buffer.

  Returns:
    image_buffer: Tensor tf.string containing the contents of a JPEG file.
89
90
91
92
    label: Tensor tf.int32 containing the label.
    bbox: 3-D float Tensor of bounding boxes arranged [1, num_boxes, coords]
      where each coordinate is [0, 1) and the coordinates are arranged as
      [ymin, xmin, ymax, xmax].
93
94
95
96
97
98
  """
  # Dense features in Example proto.
  feature_map = {
      'image/encoded': tf.FixedLenFeature([], dtype=tf.string,
                                          default_value=''),
      'image/class/label': tf.FixedLenFeature([1], dtype=tf.int64,
99
100
101
                                              default_value=-1),
      'image/class/text': tf.FixedLenFeature([], dtype=tf.string,
                                             default_value=''),
102
  }
103
104
105
106
107
108
109
  sparse_float32 = tf.VarLenFeature(dtype=tf.float32)
  # Sparse features in Example proto.
  feature_map.update(
      {k: sparse_float32 for k in ['image/object/bbox/xmin',
                                   'image/object/bbox/ymin',
                                   'image/object/bbox/xmax',
                                   'image/object/bbox/ymax']})
110

111
  features = tf.parse_single_example(example_serialized, feature_map)
112
  label = tf.cast(features['image/class/label'], dtype=tf.int32)
113

114
115
116
117
118
119
120
121
122
123
124
125
126
127
  xmin = tf.expand_dims(features['image/object/bbox/xmin'].values, 0)
  ymin = tf.expand_dims(features['image/object/bbox/ymin'].values, 0)
  xmax = tf.expand_dims(features['image/object/bbox/xmax'].values, 0)
  ymax = tf.expand_dims(features['image/object/bbox/ymax'].values, 0)

  # Note that we impose an ordering of (y, x) just to make life difficult.
  bbox = tf.concat([ymin, xmin, ymax, xmax], 0)

  # Force the variable number of bounding boxes into the shape
  # [1, num_boxes, coords].
  bbox = tf.expand_dims(bbox, 0)
  bbox = tf.transpose(bbox, [0, 2, 1])

  return features['image/encoded'], label, bbox
128
129
130
131
132
133
134
135
136
137
138
139


def parse_record(raw_record, is_training):
  """Parses a record containing a training example of an image.

  The input record is parsed into a label and image, and the image is passed
  through preprocessing steps (cropping, flipping, and so on).

  Args:
    raw_record: scalar Tensor tf.string containing a serialized
      Example protocol buffer.
    is_training: A boolean denoting whether the input is for training.
140

141
142
  Returns:
    Tuple with processed image tensor and one-hot-encoded label tensor.
143
144
145
146
147
148
  """
  image_buffer, label, bbox = _parse_example_proto(raw_record)

  image = imagenet_preprocessing.preprocess_image(
      image_buffer=image_buffer,
      bbox=bbox,
149
150
      output_height=_DEFAULT_IMAGE_SIZE,
      output_width=_DEFAULT_IMAGE_SIZE,
151
      num_channels=_NUM_CHANNELS,
152
153
      is_training=is_training)

154
  label = tf.one_hot(tf.reshape(label, shape=[]), _NUM_CLASSES)
155

156
  return image, label
157
158


159
160
def input_fn(is_training, data_dir, batch_size, num_epochs=1,
             num_parallel_calls=1, multi_gpu=False):
161
  """Input function which provides batches for train or eval.
Karmel Allison's avatar
Karmel Allison committed
162

163
164
165
166
167
  Args:
    is_training: A boolean denoting whether the input is for training.
    data_dir: The directory containing the input data.
    batch_size: The number of samples per batch.
    num_epochs: The number of epochs to repeat the dataset.
168
169
170
171
172
173
    num_parallel_calls: The number of records that are processed in parallel.
      This can be optimized per data set but for generally homogeneous data
      sets, should be approximately the number of available CPU cores.
    multi_gpu: Whether this is run multi-GPU. Note that this is only required
      currently to handle the batch leftovers, and can be removed
      when that is handled directly by Estimator.
174
175
176
177
178
179

  Returns:
    A dataset that can be used for iteration.
  """
  filenames = get_filenames(is_training, data_dir)
  dataset = tf.data.Dataset.from_tensor_slices(filenames)
180

181
  if is_training:
182
183
    # Shuffle the input files
    dataset = dataset.shuffle(buffer_size=_NUM_TRAIN_FILES)
184

185
186
  num_images = is_training and _NUM_IMAGES['train'] or _NUM_IMAGES['validation']

187
  # Convert to individual records
188
  dataset = dataset.flat_map(tf.data.TFRecordDataset)
189

190
  return resnet_run_loop.process_record_dataset(
191
      dataset, is_training, batch_size, _SHUFFLE_BUFFER, parse_record,
192
193
      num_epochs, num_parallel_calls, examples_per_epoch=num_images,
      multi_gpu=multi_gpu)
194
195
196


def get_synth_input_fn():
197
  return resnet_run_loop.get_synth_input_fn(
Karmel Allison's avatar
Karmel Allison committed
198
      _DEFAULT_IMAGE_SIZE, _DEFAULT_IMAGE_SIZE, _NUM_CHANNELS, _NUM_CLASSES)
199
200


201
202
203
###############################################################################
# Running the model
###############################################################################
204
class ImagenetModel(resnet_model.Model):
Karmel Allison's avatar
Karmel Allison committed
205
  """Model class with appropriate defaults for Imagenet data."""
206

207
  def __init__(self, resnet_size, data_format=None, num_classes=_NUM_CLASSES,
208
209
               version=resnet_model.DEFAULT_VERSION,
               dtype=resnet_model.DEFAULT_DTYPE):
Neal Wu's avatar
Neal Wu committed
210
211
212
213
214
215
216
    """These are the parameters that work for Imagenet data.

    Args:
      resnet_size: The number of convolutional layers needed in the model.
      data_format: Either 'channels_first' or 'channels_last', specifying which
        data format to use when setting up the model.
      num_classes: The number of output classes needed from the model. This
217
        enables users to extend the same model to their own datasets.
218
219
      version: Integer representing which version of the ResNet network to use.
        See README for details. Valid values: [1, 2]
220
      dtype: The TensorFlow dtype to use for calculations.
Neal Wu's avatar
Neal Wu committed
221
    """
222
223
224

    # For bigger models, we want to use "bottleneck" layers
    if resnet_size < 50:
225
      bottleneck = False
226
227
      final_size = 512
    else:
228
      bottleneck = True
229
230
231
232
      final_size = 2048

    super(ImagenetModel, self).__init__(
        resnet_size=resnet_size,
233
        bottleneck=bottleneck,
234
        num_classes=num_classes,
235
236
237
238
239
240
241
242
        num_filters=64,
        kernel_size=7,
        conv_stride=2,
        first_pool_size=3,
        first_pool_stride=2,
        block_sizes=_get_block_sizes(resnet_size),
        block_strides=[1, 2, 2, 2],
        final_size=final_size,
243
        version=version,
244
245
246
        data_format=data_format,
        dtype=dtype
    )
247
248
249


def _get_block_sizes(resnet_size):
Karmel Allison's avatar
Karmel Allison committed
250
251
252
  """Retrieve the size of each block_layer in the ResNet model.

  The number of block layers used for the Resnet model varies according
253
254
  to the size of the model. This helper grabs the layer set we want, throwing
  an error if a non-standard size has been selected.
Karmel Allison's avatar
Karmel Allison committed
255
256
257
258
259
260
261
262
263

  Args:
    resnet_size: The number of convolutional layers needed in the model.

  Returns:
    A list of block sizes to use in building the model.

  Raises:
    KeyError: if invalid resnet_size is received.
264
265
266
267
268
269
270
271
  """
  choices = {
      18: [2, 2, 2, 2],
      34: [3, 4, 6, 3],
      50: [3, 4, 6, 3],
      101: [3, 4, 23, 3],
      152: [3, 8, 36, 3],
      200: [3, 24, 36, 3]
272
273
  }

274
275
276
277
278
279
280
  try:
    return choices[resnet_size]
  except KeyError:
    err = ('Could not find layers for selected Resnet size.\n'
           'Size received: {}; sizes allowed: {}.'.format(
               resnet_size, choices.keys()))
    raise ValueError(err)
281
282


283
284
def imagenet_model_fn(features, labels, mode, params):
  """Our model_fn for ResNet to be used with our Estimator."""
285
  learning_rate_fn = resnet_run_loop.learning_rate_with_decay(
286
287
288
      batch_size=params['batch_size'], batch_denom=256,
      num_images=_NUM_IMAGES['train'], boundary_epochs=[30, 60, 80, 90],
      decay_rates=[1, 0.1, 0.01, 0.001, 1e-4])
289

290
291
292
293
294
295
296
297
298
299
300
301
302
  return resnet_run_loop.resnet_model_fn(
      features=features,
      labels=labels,
      mode=mode,
      model_class=ImagenetModel,
      resnet_size=params['resnet_size'],
      weight_decay=1e-4,
      learning_rate_fn=learning_rate_fn,
      momentum=0.9,
      data_format=params['data_format'],
      version=params['version'],
      loss_scale=params['loss_scale'],
      loss_filter_fn=None,
303
      multi_gpu=params['multi_gpu'],
304
305
      dtype=params['dtype']
  )
306
307


308
309
310
311
312
def define_imagenet_flags():
  resnet_run_loop.define_resnet_flags(
      resnet_size_choices=['18', '34', '50', '101', '152', '200'])
  flags.adopt_module_key_flags(resnet_run_loop)
  flags_core.set_defaults(train_epochs=100)
313

314

315
316
317
318
319
320
def run_imagenet(flags_obj):
  """Run ResNet ImageNet training and eval loop.

  Args:
    flags_obj: An object containing parsed flag values.
  """
321
322
  input_function = (flags_obj.use_synthetic_data and get_synth_input_fn()
                    or input_fn)
323
324

  resnet_run_loop.resnet_main(
325
      flags_obj, imagenet_model_fn, input_function,
326
      shape=[_DEFAULT_IMAGE_SIZE, _DEFAULT_IMAGE_SIZE, _NUM_CHANNELS])
327
328


329
330
331
332
def main(_):
  run_imagenet(flags.FLAGS)


333
334
if __name__ == '__main__':
  tf.logging.set_verbosity(tf.logging.INFO)
335
336
  define_imagenet_flags()
  absl_app.run(main)