resnet_run_loop.py 24.9 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# 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.
# ==============================================================================
"""Contains utility and supporting functions for ResNet.

  This module contains ResNet code which does not directly build layers. This
includes dataset management, hyperparameter and optimizer code, and argument
parsing. Code for defining the ResNet layers can be found in resnet_model.py.
"""

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

26
import functools
Taylor Robie's avatar
Taylor Robie committed
27
import math
28
29
import os

30
# pylint: disable=g-bad-import-order
31
from absl import flags
32
import tensorflow as tf
33
34

from official.resnet import resnet_model
35
from official.utils.flags import core as flags_core
36
from official.utils.export import export
37
38
from official.utils.logs import hooks_helper
from official.utils.logs import logger
39
from official.resnet import imagenet_preprocessing
40
from official.utils.misc import distribution_utils
41
from official.utils.misc import model_helpers
42
# pylint: enable=g-bad-import-order
43
44
45
46
47
48


################################################################################
# Functions for input processing.
################################################################################
def process_record_dataset(dataset, is_training, batch_size, shuffle_buffer,
Taylor Robie's avatar
Taylor Robie committed
49
                           parse_record_fn, num_epochs=1, num_gpus=None,
50
                           examples_per_epoch=None, dtype=tf.float32):
Karmel Allison's avatar
Karmel Allison committed
51
  """Given a Dataset with raw records, return an iterator over the records.
52
53
54
55
56
57
58
59
60
61
62

  Args:
    dataset: A Dataset representing raw records
    is_training: A boolean denoting whether the input is for training.
    batch_size: The number of samples per batch.
    shuffle_buffer: The buffer size to use when shuffling records. A larger
      value results in better randomness, but smaller values reduce startup
      time and use less memory.
    parse_record_fn: A function that takes a raw record and returns the
      corresponding (image, label) pair.
    num_epochs: The number of epochs to repeat the dataset.
Taylor Robie's avatar
Taylor Robie committed
63
64
    num_gpus: The number of gpus used for training.
    examples_per_epoch: The number of examples in an epoch.
65
    dtype: Data type to use for images/features.
66
67
68
69

  Returns:
    Dataset of (image, label) pairs ready for iteration.
  """
70

71
72
73
74
75
76
77
78
79
80
81
82
  # We prefetch a batch at a time, This can help smooth out the time taken to
  # load input files as we go through shuffling and processing.
  dataset = dataset.prefetch(buffer_size=batch_size)
  if is_training:
    # Shuffle the records. Note that we shuffle before repeating to ensure
    # that the shuffling respects epoch boundaries.
    dataset = dataset.shuffle(buffer_size=shuffle_buffer)

  # If we are training over multiple epochs before evaluating, repeat the
  # dataset for the appropriate number of epochs.
  dataset = dataset.repeat(num_epochs)

Taylor Robie's avatar
Taylor Robie committed
83
84
85
86
87
88
89
90
91
92
  if is_training and num_gpus and examples_per_epoch:
    total_examples = num_epochs * examples_per_epoch
    # Force the number of batches to be divisible by the number of devices.
    # This prevents some devices from receiving batches while others do not,
    # which can lead to a lockup. This case will soon be handled directly by
    # distribution strategies, at which point this .take() operation will no
    # longer be needed.
    total_batches = total_examples // batch_size // num_gpus * num_gpus
    dataset.take(total_batches * batch_size)

93
94
95
96
97
  # Parse the raw records into images and labels. Testing has shown that setting
  # num_parallel_batches > 1 produces no improvement in throughput, since
  # batch_size is almost always much greater than the number of CPU cores.
  dataset = dataset.apply(
      tf.contrib.data.map_and_batch(
98
          lambda value: parse_record_fn(value, is_training, dtype),
99
          batch_size=batch_size,
100
          num_parallel_batches=1,
101
          drop_remainder=False))
102
103
104
105

  # Operations between the final prefetch and the get_next call to the iterator
  # will happen synchronously during run time. We prefetch here again to
  # background all of the above processing work and keep it out of the
106
107
108
  # critical training path. Setting buffer_size to tf.contrib.data.AUTOTUNE
  # allows DistributionStrategies to adjust how many batches to fetch based
  # on how many devices are present.
109
  dataset = dataset.prefetch(buffer_size=tf.contrib.data.AUTOTUNE)
110
111
112
113

  return dataset


Toby Boyd's avatar
Toby Boyd committed
114
115
116
def get_synth_input_fn(height, width, num_channels, num_classes,
                       dtype=tf.float32):
  """Returns an input function that returns a dataset with random data.
117

Toby Boyd's avatar
Toby Boyd committed
118
119
120
121
  This input_fn returns a data set that iterates over a set of random data and
  bypasses all preprocessing, e.g. jpeg decode and copy. The host to device
  copy is still included. This used to find the upper throughput bound when
  tunning the full input pipeline.
122
123
124
125
126
127
128

  Args:
    height: Integer height that will be used to create a fake image tensor.
    width: Integer width that will be used to create a fake image tensor.
    num_channels: Integer depth that will be used to create a fake image tensor.
    num_classes: Number of classes that should be represented in the fake labels
      tensor
Toby Boyd's avatar
Toby Boyd committed
129
    dtype: Data type for features/images.
130
131
132
133
134

  Returns:
    An input_fn that can be used in place of a real one to return a dataset
    that can be used for iteration.
  """
Toby Boyd's avatar
Toby Boyd committed
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
  # pylint: disable=unused-argument
  def input_fn(is_training, data_dir, batch_size, *args, **kwargs):
    """Returns dataset filled with random data."""
    # Synthetic input should be within [0, 255].
    inputs = tf.truncated_normal(
        [batch_size] + [height, width, num_channels],
        dtype=dtype,
        mean=127,
        stddev=60,
        name='synthetic_inputs')

    labels = tf.random_uniform(
        [batch_size],
        minval=0,
        maxval=num_classes - 1,
        dtype=tf.int32,
        name='synthetic_labels')
    data = tf.data.Dataset.from_tensors((inputs, labels)).repeat()
    data = data.prefetch(buffer_size=tf.contrib.data.AUTOTUNE)
    return data
155
156
157
158

  return input_fn


159
def image_bytes_serving_input_fn(image_shape, dtype=tf.float32):
160
161
162
163
164
  """Serving input fn for raw jpeg images."""

  def _preprocess_image(image_bytes):
    """Preprocess a single raw image."""
    # Bounding box around the whole image.
165
    bbox = tf.constant([0.0, 0.0, 1.0, 1.0], dtype=dtype, shape=[1, 1, 4])
166
167
168
169
170
171
172
173
    height, width, num_channels = image_shape
    image = imagenet_preprocessing.preprocess_image(
        image_bytes, bbox, height, width, num_channels, is_training=False)
    return image

  image_bytes_list = tf.placeholder(
      shape=[None], dtype=tf.string, name='input_tensor')
  images = tf.map_fn(
174
      _preprocess_image, image_bytes_list, back_prop=False, dtype=dtype)
175
176
177
178
  return tf.estimator.export.TensorServingInputReceiver(
      images, {'image_bytes': image_bytes_list})


179
180
181
182
################################################################################
# Functions for running training/eval/validation loops for the model.
################################################################################
def learning_rate_with_decay(
183
184
    batch_size, batch_denom, num_images, boundary_epochs, decay_rates,
    base_lr=0.1, warmup=False):
185
186
187
188
189
190
191
192
193
194
195
  """Get a learning rate that decays step-wise as training progresses.

  Args:
    batch_size: the number of examples processed in each training batch.
    batch_denom: this value will be used to scale the base learning rate.
      `0.1 * batch size` is divided by this number, such that when
      batch_denom == batch_size, the initial learning rate will be 0.1.
    num_images: total number of images that will be used for training.
    boundary_epochs: list of ints representing the epochs at which we
      decay the learning rate.
    decay_rates: list of floats representing the decay rates to be used
196
197
      for scaling the learning rate. It should have one more element
      than `boundary_epochs`, and all elements should have the same type.
198
199
    base_lr: Initial learning rate scaled based on batch_denom.
    warmup: Run a 5 epoch warmup to the initial lr.
200
201
202
203
204
  Returns:
    Returns a function that takes a single argument - the number of batches
    trained so far (global_step)- and returns the learning rate to be used
    for training the next batch.
  """
205
  initial_learning_rate = base_lr * batch_size / batch_denom
206
207
  batches_per_epoch = num_images / batch_size

Taylor Robie's avatar
Taylor Robie committed
208
209
210
  # Reduce the learning rate at certain epochs.
  # CIFAR-10: divide by 10 at epoch 100, 150, and 200
  # ImageNet: divide by 10 at epoch 30, 60, 80, and 90
211
212
213
214
  boundaries = [int(batches_per_epoch * epoch) for epoch in boundary_epochs]
  vals = [initial_learning_rate * decay for decay in decay_rates]

  def learning_rate_fn(global_step):
215
216
217
218
219
220
221
222
223
    """Builds scaled learning rate function with 5 epoch warm up."""
    lr = tf.train.piecewise_constant(global_step, boundaries, vals)
    if warmup:
      warmup_steps = int(batches_per_epoch * 5)
      warmup_lr = (
          initial_learning_rate * tf.cast(global_step, tf.float32) / tf.cast(
              warmup_steps, tf.float32))
      return tf.cond(global_step < warmup_steps, lambda: warmup_lr, lambda: lr)
    return lr
224
225
226
227
228
229

  return learning_rate_fn


def resnet_model_fn(features, labels, mode, model_class,
                    resnet_size, weight_decay, learning_rate_fn, momentum,
230
                    data_format, resnet_version, loss_scale,
Zac Wellmer's avatar
Zac Wellmer committed
231
232
                    loss_filter_fn=None, dtype=resnet_model.DEFAULT_DTYPE,
                    fine_tune=False):
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
  """Shared functionality for different resnet model_fns.

  Initializes the ResnetModel representing the model layers
  and uses that model to build the necessary EstimatorSpecs for
  the `mode` in question. For training, this means building losses,
  the optimizer, and the train op that get passed into the EstimatorSpec.
  For evaluation and prediction, the EstimatorSpec is returned without
  a train op, but with the necessary parameters for the given mode.

  Args:
    features: tensor representing input images
    labels: tensor representing class labels for all input images
    mode: current estimator mode; should be one of
      `tf.estimator.ModeKeys.TRAIN`, `EVALUATE`, `PREDICT`
    model_class: a class representing a TensorFlow model that has a __call__
      function. We assume here that this is a subclass of ResnetModel.
    resnet_size: A single integer for the size of the ResNet model.
    weight_decay: weight decay loss rate used to regularize learned variables.
    learning_rate_fn: function that returns the current learning rate given
      the current global_step
    momentum: momentum term used for optimization
    data_format: Input format ('channels_last', 'channels_first', or None).
      If set to None, the format is dependent on whether a GPU is available.
256
257
    resnet_version: Integer representing which version of the ResNet network to
      use. See README for details. Valid values: [1, 2]
258
259
    loss_scale: The factor to scale the loss for numerical stability. A detailed
      summary is present in the arg parser help text.
260
261
262
263
    loss_filter_fn: function that takes a string variable name and returns
      True if the var should be included in loss calculation, and False
      otherwise. If None, batch_normalization variables will be excluded
      from the loss.
264
    dtype: the TensorFlow dtype to use for calculations.
Zac Wellmer's avatar
Zac Wellmer committed
265
    fine_tune: If True only train the dense layers(final layers).
266
267
268
269
270
271
272
273

  Returns:
    EstimatorSpec parameterized according to the input params and the
    current mode.
  """

  # Generate a summary node for the images
  tf.summary.image('images', features, max_outputs=6)
274
275
  # Checks that features/images have same data type being used for calculations.
  assert features.dtype == dtype
276

277
278
  model = model_class(resnet_size, data_format, resnet_version=resnet_version,
                      dtype=dtype)
279

280
281
  logits = model(features, mode == tf.estimator.ModeKeys.TRAIN)

282
283
284
285
286
  # This acts as a no-op if the logits are already in fp32 (provided logits are
  # not a SparseTensor). If dtype is is low precision, logits must be cast to
  # fp32 for numerical stability.
  logits = tf.cast(logits, tf.float32)

287
288
289
290
291
292
  predictions = {
      'classes': tf.argmax(logits, axis=1),
      'probabilities': tf.nn.softmax(logits, name='softmax_tensor')
  }

  if mode == tf.estimator.ModeKeys.PREDICT:
293
294
295
296
297
298
299
    # Return the predictions and the specification for serving a SavedModel
    return tf.estimator.EstimatorSpec(
        mode=mode,
        predictions=predictions,
        export_outputs={
            'predict': tf.estimator.export.PredictOutput(predictions)
        })
300
301

  # Calculate loss, which includes softmax cross entropy and L2 regularization.
302
303
  cross_entropy = tf.losses.sparse_softmax_cross_entropy(
      logits=logits, labels=labels)
304
305
306
307
308
309
310

  # Create a tensor named cross_entropy for logging purposes.
  tf.identity(cross_entropy, name='cross_entropy')
  tf.summary.scalar('cross_entropy', cross_entropy)

  # If no loss_filter_fn is passed, assume we want the default behavior,
  # which is that batch_normalization variables are excluded from loss.
Karmel Allison's avatar
Karmel Allison committed
311
312
313
  def exclude_batch_norm(name):
    return 'batch_normalization' not in name
  loss_filter_fn = loss_filter_fn or exclude_batch_norm
314
315

  # Add weight decay to the loss.
316
  l2_loss = weight_decay * tf.add_n(
317
318
      # loss is computed using fp32 for numerical stability.
      [tf.nn.l2_loss(tf.cast(v, tf.float32)) for v in tf.trainable_variables()
319
       if loss_filter_fn(v.name)])
320
321
  tf.summary.scalar('l2_loss', l2_loss)
  loss = cross_entropy + l2_loss
322
323
324
325
326
327
328
329
330
331
332
333

  if mode == tf.estimator.ModeKeys.TRAIN:
    global_step = tf.train.get_or_create_global_step()

    learning_rate = learning_rate_fn(global_step)

    # Create a tensor named learning_rate for logging purposes
    tf.identity(learning_rate, name='learning_rate')
    tf.summary.scalar('learning_rate', learning_rate)

    optimizer = tf.train.MomentumOptimizer(
        learning_rate=learning_rate,
334
335
        momentum=momentum
    )
336

Zac Wellmer's avatar
Zac Wellmer committed
337
    def _dense_grad_filter(gvs):
338
339
340
341
      """Only apply gradient updates to the final layer.

      This function is used for fine tuning.

Zac Wellmer's avatar
Zac Wellmer committed
342
      Args:
343
        gvs: list of tuples with gradients and variable info
Zac Wellmer's avatar
Zac Wellmer committed
344
      Returns:
345
346
        filtered gradients so that only the dense layer remains
      """
Zac Wellmer's avatar
Zac Wellmer committed
347
348
      return [(g, v) for g, v in gvs if 'dense' in v.name]

349
350
351
352
353
354
    if loss_scale != 1:
      # When computing fp16 gradients, often intermediate tensor values are
      # so small, they underflow to 0. To avoid this, we multiply the loss by
      # loss_scale to make these tensor values loss_scale times bigger.
      scaled_grad_vars = optimizer.compute_gradients(loss * loss_scale)

Zac Wellmer's avatar
Zac Wellmer committed
355
356
357
      if fine_tune:
        scaled_grad_vars = _dense_grad_filter(scaled_grad_vars)

358
359
360
361
362
363
      # Once the gradient computation is complete we can scale the gradients
      # back to the correct scale before passing them to the optimizer.
      unscaled_grad_vars = [(grad / loss_scale, var)
                            for grad, var in scaled_grad_vars]
      minimize_op = optimizer.apply_gradients(unscaled_grad_vars, global_step)
    else:
Zac Wellmer's avatar
Zac Wellmer committed
364
365
366
367
      grad_vars = optimizer.compute_gradients(loss)
      if fine_tune:
        grad_vars = _dense_grad_filter(grad_vars)
      minimize_op = optimizer.apply_gradients(grad_vars, global_step)
368

369
    update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
370
    train_op = tf.group(minimize_op, update_ops)
371
372
373
  else:
    train_op = None

374
  accuracy = tf.metrics.accuracy(labels, predictions['classes'])
375
376
377
378
379
380
  accuracy_top_5 = tf.metrics.mean(tf.nn.in_top_k(predictions=logits,
                                                  targets=labels,
                                                  k=5,
                                                  name='top_5_op'))
  metrics = {'accuracy': accuracy,
             'accuracy_top_5': accuracy_top_5}
381
382
383

  # Create a tensor named train_accuracy for logging purposes
  tf.identity(accuracy[1], name='train_accuracy')
384
  tf.identity(accuracy_top_5[1], name='train_accuracy_top_5')
385
  tf.summary.scalar('train_accuracy', accuracy[1])
386
  tf.summary.scalar('train_accuracy_top_5', accuracy_top_5[1])
387
388
389
390
391
392
393
394
395

  return tf.estimator.EstimatorSpec(
      mode=mode,
      predictions=predictions,
      loss=loss,
      train_op=train_op,
      eval_metric_ops=metrics)


396
397
def resnet_main(
    flags_obj, model_function, input_function, dataset_name, shape=None):
398
399
400
  """Shared main loop for ResNet Models.

  Args:
401
402
    flags_obj: An object containing parsed flags. See define_resnet_flags()
      for details.
403
404
405
406
407
    model_function: the function that instantiates the Model and builds the
      ops for train/eval. This will be passed directly into the estimator.
    input_function: the function that processes the dataset and returns a
      dataset that the estimator can train on. This will be wrapped with
      all the relevant flags for running and passed to estimator.
408
409
    dataset_name: the name of the dataset for training and evaluation. This is
      used for logging purpose.
410
    shape: list of ints representing the shape of the images used for training.
411
      This is only used if flags_obj.export_dir is passed.
412
  """
Karmel Allison's avatar
Karmel Allison committed
413

414
415
  model_helpers.apply_clean(flags.FLAGS)

416
417
418
419
420
421
422
423
  # Using the Winograd non-fused algorithms provides a small performance boost.
  os.environ['TF_ENABLE_WINOGRAD_NONFUSED'] = '1'

  # Create session config based on values of inter_op_parallelism_threads and
  # intra_op_parallelism_threads. Note that we default to having
  # allow_soft_placement = True, which is required for multi-GPU and not
  # harmful for other modes.
  session_config = tf.ConfigProto(
424
425
      inter_op_parallelism_threads=flags_obj.inter_op_parallelism_threads,
      intra_op_parallelism_threads=flags_obj.intra_op_parallelism_threads,
426
427
      allow_soft_placement=True)

428
429
  distribution_strategy = distribution_utils.get_distribution_strategy(
      flags_core.get_num_gpus(flags_obj), flags_obj.all_reduce_alg)
430

431
432
  run_config = tf.estimator.RunConfig(
      train_distribute=distribution_strategy, session_config=session_config)
433

Zac Wellmer's avatar
Zac Wellmer committed
434
435
436
437
438
439
440
441
  # initialize our model with all but the dense layer from pretrained resnet
  if flags_obj.pretrained_model_checkpoint_path is not None:
    warm_start_settings = tf.estimator.WarmStartSettings(
        flags_obj.pretrained_model_checkpoint_path,
        vars_to_warm_start='^(?!.*dense)')
  else:
    warm_start_settings = None

442
  classifier = tf.estimator.Estimator(
443
      model_fn=model_function, model_dir=flags_obj.model_dir, config=run_config,
Zac Wellmer's avatar
Zac Wellmer committed
444
      warm_start_from=warm_start_settings, params={
445
446
447
          'resnet_size': int(flags_obj.resnet_size),
          'data_format': flags_obj.data_format,
          'batch_size': flags_obj.batch_size,
448
          'resnet_version': int(flags_obj.resnet_version),
449
          'loss_scale': flags_core.get_loss_scale(flags_obj),
Zac Wellmer's avatar
Zac Wellmer committed
450
451
          'dtype': flags_core.get_tf_dtype(flags_obj),
          'fine_tune': flags_obj.fine_tune
452
453
      })

454
455
456
457
  run_params = {
      'batch_size': flags_obj.batch_size,
      'dtype': flags_core.get_tf_dtype(flags_obj),
      'resnet_size': flags_obj.resnet_size,
458
      'resnet_version': flags_obj.resnet_version,
459
460
461
      'synthetic_data': flags_obj.use_synthetic_data,
      'train_epochs': flags_obj.train_epochs,
  }
462
  if flags_obj.use_synthetic_data:
463
    dataset_name = dataset_name + '-synthetic'
464

465
  benchmark_logger = logger.get_benchmark_logger()
466
467
  benchmark_logger.log_run_info('resnet', dataset_name, run_params,
                                test_id=flags_obj.benchmark_test_id)
468

469
  train_hooks = hooks_helper.get_train_hooks(
470
      flags_obj.hooks,
471
      model_dir=flags_obj.model_dir,
472
      batch_size=flags_obj.batch_size)
473

Taylor Robie's avatar
Taylor Robie committed
474
  def input_fn_train(num_epochs):
475
476
    return input_function(
        is_training=True, data_dir=flags_obj.data_dir,
477
        batch_size=distribution_utils.per_device_batch_size(
478
            flags_obj.batch_size, flags_core.get_num_gpus(flags_obj)),
Taylor Robie's avatar
Taylor Robie committed
479
        num_epochs=num_epochs,
480
481
        num_gpus=flags_core.get_num_gpus(flags_obj),
        dtype=flags_core.get_tf_dtype(flags_obj))
482

483
  def input_fn_eval():
484
485
    return input_function(
        is_training=False, data_dir=flags_obj.data_dir,
486
        batch_size=distribution_utils.per_device_batch_size(
487
            flags_obj.batch_size, flags_core.get_num_gpus(flags_obj)),
488
489
        num_epochs=1,
        dtype=flags_core.get_tf_dtype(flags_obj))
Taylor Robie's avatar
Taylor Robie committed
490

Taylor Robie's avatar
Taylor Robie committed
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
  if flags_obj.eval_only or not flags_obj.train_epochs:
    # If --eval_only is set, perform a single loop with zero train epochs.
    schedule, n_loops = [0], 1
  else:
    # Compute the number of times to loop while training. All but the last
    # pass will train for `epochs_between_evals` epochs, while the last will
    # train for the number needed to reach `training_epochs`. For instance if
    #   train_epochs = 25 and epochs_between_evals = 10
    # schedule will be set to [10, 10, 5]. That is to say, the loop will:
    #   Train for 10 epochs and then evaluate.
    #   Train for another 10 epochs and then evaluate.
    #   Train for a final 5 epochs (to reach 25 epochs) and then evaluate.
    n_loops = math.ceil(flags_obj.train_epochs / flags_obj.epochs_between_evals)
    schedule = [flags_obj.epochs_between_evals for _ in range(int(n_loops))]
    schedule[-1] = flags_obj.train_epochs - sum(schedule[:-1])  # over counting.

  for cycle_index, num_train_epochs in enumerate(schedule):
    tf.logging.info('Starting cycle: %d/%d', cycle_index, int(n_loops))

    if num_train_epochs:
      classifier.train(input_fn=lambda: input_fn_train(num_train_epochs),
                       hooks=train_hooks, max_steps=flags_obj.max_train_steps)
513

514
    tf.logging.info('Starting to evaluate.')
515
516
517
518
519

    # flags_obj.max_train_steps is generally associated with testing and
    # profiling. As a result it is frequently called with synthetic data, which
    # will iterate forever. Passing steps=flags_obj.max_train_steps allows the
    # eval (which is generally unimportant in those circumstances) to terminate.
520
521
522
    # Note that eval will run for max_train_steps each loop, regardless of the
    # global_step count.
    eval_results = classifier.evaluate(input_fn=input_fn_eval,
523
                                       steps=flags_obj.max_train_steps)
524

Qianli Scott Zhu's avatar
Qianli Scott Zhu committed
525
    benchmark_logger.log_evaluation_result(eval_results)
526

527
    if model_helpers.past_stop_threshold(
528
        flags_obj.stop_threshold, eval_results['accuracy']):
529
530
      break

531
  if flags_obj.export_dir is not None:
532
    # Exports a saved model for the given classifier.
533
    export_dtype = flags_core.get_tf_dtype(flags_obj)
534
    if flags_obj.image_bytes_as_serving_input:
535
536
      input_receiver_fn = functools.partial(
          image_bytes_serving_input_fn, shape, dtype=export_dtype)
537
538
    else:
      input_receiver_fn = export.build_tensor_serving_input_receiver_fn(
539
540
541
          shape, batch_size=flags_obj.batch_size, dtype=export_dtype)
    classifier.export_savedmodel(flags_obj.export_dir, input_receiver_fn,
                                 strip_default_attrs=True)
542
543


544
545
546
def define_resnet_flags(resnet_size_choices=None):
  """Add flags and validators for ResNet."""
  flags_core.define_base()
547
  flags_core.define_performance(num_parallel_calls=False)
548
549
550
  flags_core.define_image()
  flags_core.define_benchmark()
  flags.adopt_module_key_flags(flags_core)
551

552
  flags.DEFINE_enum(
Toby Boyd's avatar
Toby Boyd committed
553
      name='resnet_version', short_name='rv', default='1',
554
      enum_values=['1', '2'],
555
556
      help=flags_core.help_wrap(
          'Version of ResNet. (1 or 2) See README.md for details.'))
Zac Wellmer's avatar
Zac Wellmer committed
557
558
559
560
561
562
563
564
565
  flags.DEFINE_bool(
      name='fine_tune', short_name='ft', default=False,
      help=flags_core.help_wrap(
          'If True do not train any parameters except for the final layer.'))
  flags.DEFINE_string(
      name='pretrained_model_checkpoint_path', short_name='pmcp', default=None,
      help=flags_core.help_wrap(
          'If not None initialize all the network except the final layer with '
          'these values'))
Taylor Robie's avatar
Taylor Robie committed
566
  flags.DEFINE_boolean(
567
      name='eval_only', default=False,
Taylor Robie's avatar
Taylor Robie committed
568
569
      help=flags_core.help_wrap('Skip training and only perform evaluation on '
                                'the latest checkpoint.'))
570
  flags.DEFINE_boolean(
571
      name="image_bytes_as_serving_input", default=False,
572
573
574
575
576
577
578
      help=flags_core.help_wrap(
          'If True exports savedmodel with serving signature that accepts '
          'JPEG image bytes instead of a fixed size [HxWxC] tensor that '
          'represents the image. The former is easier to use for serving at '
          'the expense of image resize/cropping being done as part of model '
          'inference. Note, this flag only applies to ImageNet and cannot '
          'be used for CIFAR.'))
579

580
581
582
  choice_kwargs = dict(
      name='resnet_size', short_name='rs', default='50',
      help=flags_core.help_wrap('The size of the ResNet model to use.'))
583

584
585
586
587
  if resnet_size_choices is None:
    flags.DEFINE_string(**choice_kwargs)
  else:
    flags.DEFINE_enum(enum_values=resnet_size_choices, **choice_kwargs)