imagenet_main.py 12.2 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.utils.logs import logger
29
from official.resnet import imagenet_preprocessing
30
31
from official.resnet import resnet_model
from official.resnet import resnet_run_loop
32

33
34
35
DEFAULT_IMAGE_SIZE = 224
NUM_CHANNELS = 3
NUM_CLASSES = 1001
36

37
NUM_IMAGES = {
38
39
40
    'train': 1281167,
    'validation': 50000,
}
41

42
_NUM_TRAIN_FILES = 1024
43
_SHUFFLE_BUFFER = 10000
44

45
DATASET_NAME = 'ImageNet'
46

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


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

65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
  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>
84
85
86
87
88
89
90

  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.
91
92
93
94
    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].
95
96
97
  """
  # Dense features in Example proto.
  feature_map = {
98
      'image/encoded': tf.io.FixedLenFeature([], dtype=tf.string,
99
                                             default_value=''),
100
101
102
103
      'image/class/label': tf.io.FixedLenFeature([], dtype=tf.int64,
                                                 default_value=-1),
      'image/class/text': tf.io.FixedLenFeature([], dtype=tf.string,
                                                default_value=''),
104
  }
105
  sparse_float32 = tf.io.VarLenFeature(dtype=tf.float32)
106
107
108
109
110
111
  # 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']})
112

113
114
  features = tf.io.parse_single_example(serialized=example_serialized,
                                        features=feature_map)
115
  label = tf.cast(features['image/class/label'], dtype=tf.int32)
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)
128
  bbox = tf.transpose(a=bbox, perm=[0, 2, 1])
129
130

  return features['image/encoded'], label, bbox
131
132


133
def parse_record(raw_record, is_training, dtype):
134
135
136
137
138
139
140
141
142
  """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.
143
    dtype: data type to use for images/features.
144

145
146
  Returns:
    Tuple with processed image tensor and one-hot-encoded label tensor.
147
148
149
150
151
152
  """
  image_buffer, label, bbox = _parse_example_proto(raw_record)

  image = imagenet_preprocessing.preprocess_image(
      image_buffer=image_buffer,
      bbox=bbox,
153
154
155
      output_height=DEFAULT_IMAGE_SIZE,
      output_width=DEFAULT_IMAGE_SIZE,
      num_channels=NUM_CHANNELS,
156
      is_training=is_training)
157
  image = tf.cast(image, dtype)
158

159
  return image, label
160
161


Toby Boyd's avatar
Toby Boyd committed
162
163
def input_fn(is_training, data_dir, batch_size, num_epochs=1,
             dtype=tf.float32, datasets_num_private_threads=None,
Priya Gupta's avatar
Priya Gupta committed
164
             num_parallel_batches=1, parse_record_fn=parse_record):
165
  """Input function which provides batches for train or eval.
Karmel Allison's avatar
Karmel Allison committed
166

167
168
169
170
171
  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.
172
    dtype: Data type to use for images/features
Toby Boyd's avatar
Toby Boyd committed
173
174
    datasets_num_private_threads: Number of private threads for tf.data.
    num_parallel_batches: Number of parallel batches for tf.data.
Priya Gupta's avatar
Priya Gupta committed
175
    parse_record_fn: Function to use for parsing the records.
176
177
178
179
180
181

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

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

187
188
189
190
191
  # Convert to individual records.
  # cycle_length = 10 means 10 files will be read and deserialized in parallel.
  # This number is low enough to not cause too much contention on small systems
  # but high enough to provide the benefits of parallelization. You may want
  # to increase this number if you have a large number of CPU cores.
192
  dataset = dataset.apply(tf.data.experimental.parallel_interleave(
193
      tf.data.TFRecordDataset, cycle_length=10))
194

195
  return resnet_run_loop.process_record_dataset(
Taylor Robie's avatar
Taylor Robie committed
196
197
198
199
      dataset=dataset,
      is_training=is_training,
      batch_size=batch_size,
      shuffle_buffer=_SHUFFLE_BUFFER,
Priya Gupta's avatar
Priya Gupta committed
200
      parse_record_fn=parse_record_fn,
Taylor Robie's avatar
Taylor Robie committed
201
      num_epochs=num_epochs,
Toby Boyd's avatar
Toby Boyd committed
202
203
204
      dtype=dtype,
      datasets_num_private_threads=datasets_num_private_threads,
      num_parallel_batches=num_parallel_batches
205
  )
206
207


Toby Boyd's avatar
Toby Boyd committed
208
def get_synth_input_fn(dtype):
209
  return resnet_run_loop.get_synth_input_fn(
210
      DEFAULT_IMAGE_SIZE, DEFAULT_IMAGE_SIZE, NUM_CHANNELS, NUM_CLASSES,
Toby Boyd's avatar
Toby Boyd committed
211
      dtype=dtype)
212
213


214
215
216
###############################################################################
# Running the model
###############################################################################
217
class ImagenetModel(resnet_model.Model):
Karmel Allison's avatar
Karmel Allison committed
218
  """Model class with appropriate defaults for Imagenet data."""
219

220
  def __init__(self, resnet_size, data_format=None, num_classes=NUM_CLASSES,
221
               resnet_version=resnet_model.DEFAULT_VERSION,
222
               dtype=resnet_model.DEFAULT_DTYPE):
Neal Wu's avatar
Neal Wu committed
223
224
225
226
227
228
229
    """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
230
        enables users to extend the same model to their own datasets.
231
232
      resnet_version: Integer representing which version of the ResNet network
        to use. See README for details. Valid values: [1, 2]
233
      dtype: The TensorFlow dtype to use for calculations.
Neal Wu's avatar
Neal Wu committed
234
    """
235
236
237

    # For bigger models, we want to use "bottleneck" layers
    if resnet_size < 50:
238
      bottleneck = False
239
    else:
240
      bottleneck = True
241
242
243

    super(ImagenetModel, self).__init__(
        resnet_size=resnet_size,
244
        bottleneck=bottleneck,
245
        num_classes=num_classes,
246
247
248
249
250
251
252
        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],
253
        resnet_version=resnet_version,
254
255
256
        data_format=data_format,
        dtype=dtype
    )
257
258
259


def _get_block_sizes(resnet_size):
Karmel Allison's avatar
Karmel Allison committed
260
261
262
  """Retrieve the size of each block_layer in the ResNet model.

  The number of block layers used for the Resnet model varies according
263
264
  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
265
266
267
268
269
270
271
272
273

  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.
274
275
276
277
278
279
280
281
  """
  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]
282
283
  }

284
285
286
287
288
289
290
  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)
291
292


293
294
def imagenet_model_fn(features, labels, mode, params):
  """Our model_fn for ResNet to be used with our Estimator."""
295
296
297
298
299
300
301
302
303
304

  # Warmup and higher lr may not be valid for fine tuning with small batches
  # and smaller numbers of training images.
  if params['fine_tune']:
    warmup = False
    base_lr = .1
  else:
    warmup = True
    base_lr = .128

305
  learning_rate_fn = resnet_run_loop.learning_rate_with_decay(
306
      batch_size=params['batch_size'], batch_denom=256,
307
      num_images=NUM_IMAGES['train'], boundary_epochs=[30, 60, 80, 90],
308
      decay_rates=[1, 0.1, 0.01, 0.001, 1e-4], warmup=warmup, base_lr=base_lr)
309

310
311
312
313
314
315
316
317
318
319
  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'],
320
      resnet_version=params['resnet_version'],
321
322
      loss_scale=params['loss_scale'],
      loss_filter_fn=None,
Zac Wellmer's avatar
Zac Wellmer committed
323
324
      dtype=params['dtype'],
      fine_tune=params['fine_tune']
325
  )
326
327


328
329
330
331
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)
Toby Boyd's avatar
Toby Boyd committed
332
  flags_core.set_defaults(train_epochs=90)
333

334

335
336
337
338
339
340
def run_imagenet(flags_obj):
  """Run ResNet ImageNet training and eval loop.

  Args:
    flags_obj: An object containing parsed flag values.
  """
Toby Boyd's avatar
Toby Boyd committed
341
342
343
  input_function = (flags_obj.use_synthetic_data and
                    get_synth_input_fn(flags_core.get_tf_dtype(flags_obj)) or
                    input_fn)
344
345

  resnet_run_loop.resnet_main(
346
      flags_obj, imagenet_model_fn, input_function, DATASET_NAME,
347
      shape=[DEFAULT_IMAGE_SIZE, DEFAULT_IMAGE_SIZE, NUM_CHANNELS])
348
349


350
def main(_):
351
352
  with logger.benchmark_context(flags.FLAGS):
    run_imagenet(flags.FLAGS)
353
354


355
if __name__ == '__main__':
356
  tf.compat.v1.logging.set_verbosity(tf.compat.v1.logging.INFO)
357
358
  define_imagenet_flags()
  absl_app.run(main)