resnet_ctl_imagenet_benchmark.py 14.6 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# Copyright 2019 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.
# ==============================================================================
"""Executes CTL benchmarks and accuracy tests."""
Hongkun Yu's avatar
Hongkun Yu committed
16
# pylint: disable=line-too-long,g-bad-import-order
17
18
19
20
21
22
23
24
from __future__ import print_function

import os
import time

from absl import flags
import tensorflow as tf

25
26
from official.vision.image_classification.resnet import common
from official.vision.image_classification.resnet import resnet_ctl_imagenet_main
27
from official.benchmark.perfzero_benchmark import PerfZeroBenchmark
28
from official.benchmark import benchmark_wrappers
29
from official.utils.flags import core as flags_core
30
31
32
33
34
35
36
37
38
39
40
41
42
43

MIN_TOP_1_ACCURACY = 0.76
MAX_TOP_1_ACCURACY = 0.77

FLAGS = flags.FLAGS


class CtlBenchmark(PerfZeroBenchmark):
  """Base benchmark class with methods to simplify testing."""

  def __init__(self, output_dir=None, default_flags=None, flag_methods=None):
    self.default_flags = default_flags or {}
    self.flag_methods = flag_methods or {}
    super(CtlBenchmark, self).__init__(
Zongwei Zhou's avatar
Zongwei Zhou committed
44
        output_dir=output_dir,
45
46
47
48
49
50
51
52
53
54
        default_flags=self.default_flags,
        flag_methods=self.flag_methods)

  def _report_benchmark(self,
                        stats,
                        wall_time_sec,
                        top_1_max=None,
                        top_1_min=None,
                        total_batch_size=None,
                        log_steps=None,
A. Unique TensorFlower's avatar
A. Unique TensorFlower committed
55
56
                        warmup=1,
                        start_time_sec=None):
57
58
59
60
61
62
63
64
65
66
    """Report benchmark results by writing to local protobuf file.

    Args:
      stats: dict returned from keras models with known entries.
      wall_time_sec: the during of the benchmark execution in seconds
      top_1_max: highest passing level for top_1 accuracy.
      top_1_min: lowest passing level for top_1 accuracy.
      total_batch_size: Global batch-size.
      log_steps: How often the log was created for stats['step_timestamp_log'].
      warmup: number of entries in stats['step_timestamp_log'] to ignore.
A. Unique TensorFlower's avatar
A. Unique TensorFlower committed
67
      start_time_sec: the start time of the program in seconds since epoch.
68
69
70
71
    """

    metrics = []
    if 'eval_acc' in stats:
72
73
74
75
76
77
78
79
80
81
82
83
84
      metrics.append({
          'name': 'accuracy_top_1',
          'value': stats['eval_acc'],
          'min_value': top_1_min,
          'max_value': top_1_max
      })
      metrics.append({'name': 'eval_loss', 'value': stats['eval_loss']})

      metrics.append({
          'name': 'top_1_train_accuracy',
          'value': stats['train_acc']
      })
      metrics.append({'name': 'train_loss', 'value': stats['train_loss']})
85
86

    if (warmup and 'step_timestamp_log' in stats and
Ruoxin Sang's avatar
Ruoxin Sang committed
87
88
        len(stats['step_timestamp_log']) > warmup + 1):
      # first entry in the time_log is start of step 0. The rest of the
89
90
      # entries are the end of each step recorded
      time_log = stats['step_timestamp_log']
Will Cromar's avatar
Will Cromar committed
91
92
93
      steps_elapsed = time_log[-1].batch_index - time_log[warmup].batch_index
      time_elapsed = time_log[-1].timestamp - time_log[warmup].timestamp
      examples_per_sec = total_batch_size * (steps_elapsed / time_elapsed)
94
      metrics.append({'name': 'exp_per_second', 'value': examples_per_sec})
95
96

    if 'avg_exp_per_second' in stats:
97
98
99
100
      metrics.append({
          'name': 'avg_exp_per_second',
          'value': stats['avg_exp_per_second']
      })
101

A. Unique TensorFlower's avatar
A. Unique TensorFlower committed
102
103
104
105
106
107
    if start_time_sec and 'step_timestamp_log' in stats:
      time_log = stats['step_timestamp_log']
      # time_log[0] is recorded at the beginning of the first step.
      startup_time = time_log[0].timestamp - start_time_sec
      metrics.append({'name': 'startup_time', 'value': startup_time})

108
    flags_str = flags_core.get_nondefault_flags_as_str()
109
110
111
112
113
    self.report_benchmark(
        iters=-1,
        wall_time=wall_time_sec,
        metrics=metrics,
        extras={'flags': flags_str})
114
115
116
117
118
119
120
121
122
123
124
125


class Resnet50CtlAccuracy(CtlBenchmark):
  """Benchmark accuracy tests for ResNet50 in CTL."""

  def __init__(self, output_dir=None, root_data_dir=None, **kwargs):
    """A benchmark class.

    Args:
      output_dir: directory where to output e.g. log files
      root_data_dir: directory under which to look for dataset
      **kwargs: arbitrary named arguments. This is needed to make the
126
127
        constructor forward compatible in case PerfZero provides more named
        arguments before updating the constructor.
128
129
    """

Hongkun Yu's avatar
Hongkun Yu committed
130
    flag_methods = [common.define_keras_flags]
131

132
    self.data_dir = os.path.join(root_data_dir, 'imagenet')
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
    super(Resnet50CtlAccuracy, self).__init__(
        output_dir=output_dir, flag_methods=flag_methods)

  def benchmark_8_gpu(self):
    """Test Keras model with eager, dist_strat and 8 GPUs."""
    self._setup()
    FLAGS.num_gpus = 8
    FLAGS.data_dir = self.data_dir
    FLAGS.batch_size = 128 * 8
    FLAGS.train_epochs = 90
    FLAGS.epochs_between_evals = 10
    FLAGS.model_dir = self._get_model_dir('benchmark_8_gpu')
    FLAGS.dtype = 'fp32'
    self._run_and_report_benchmark()

148
149
150
151
152
153
154
155
156
157
158
159
  def benchmark_8_gpu_fp16(self):
    """Test Keras model with eager, 8 GPUs with tf.keras mixed precision."""
    self._setup()
    FLAGS.num_gpus = 8
    FLAGS.data_dir = self.data_dir
    FLAGS.batch_size = 256 * 8
    FLAGS.train_epochs = 90
    FLAGS.epochs_between_evals = 10
    FLAGS.model_dir = self._get_model_dir('benchmark_8_gpu_fp16')
    FLAGS.dtype = 'fp16'
    self._run_and_report_benchmark()

160
  def benchmark_8_gpu_amp(self):
161
    """Test Keras model with 8 GPUs and mixed precision via graph rewrite."""
162
163
164
    self._setup()
    FLAGS.num_gpus = 8
    FLAGS.data_dir = self.data_dir
165
    FLAGS.batch_size = 256 * 8
166
167
168
169
170
171
172
    FLAGS.train_epochs = 90
    FLAGS.epochs_between_evals = 10
    FLAGS.model_dir = self._get_model_dir('benchmark_8_gpu_amp')
    FLAGS.dtype = 'fp16'
    FLAGS.fp16_implementation = 'graph_rewrite'
    self._run_and_report_benchmark()

173
  @benchmark_wrappers.enable_runtime_flags
174
175
  def _run_and_report_benchmark(self):
    start_time_sec = time.time()
Hongkun Yu's avatar
Hongkun Yu committed
176
    stats = resnet_ctl_imagenet_main.run(flags.FLAGS)
177
178
179
180
181
182
183
184
    wall_time_sec = time.time() - start_time_sec

    super(Resnet50CtlAccuracy, self)._report_benchmark(
        stats,
        wall_time_sec,
        top_1_min=MIN_TOP_1_ACCURACY,
        top_1_max=MAX_TOP_1_ACCURACY,
        total_batch_size=FLAGS.batch_size,
A. Unique TensorFlower's avatar
A. Unique TensorFlower committed
185
186
        log_steps=100,
        start_time_sec=start_time_sec)
187
188
189
190
191
192


class Resnet50CtlBenchmarkBase(CtlBenchmark):
  """Resnet50 benchmarks."""

  def __init__(self, output_dir=None, default_flags=None):
Hongkun Yu's avatar
Hongkun Yu committed
193
    flag_methods = [common.define_keras_flags]
194
195
196
197
198
199

    super(Resnet50CtlBenchmarkBase, self).__init__(
        output_dir=output_dir,
        flag_methods=flag_methods,
        default_flags=default_flags)

200
  @benchmark_wrappers.enable_runtime_flags
201
202
  def _run_and_report_benchmark(self):
    start_time_sec = time.time()
Hongkun Yu's avatar
Hongkun Yu committed
203
    stats = resnet_ctl_imagenet_main.run(FLAGS)
204
205
    wall_time_sec = time.time() - start_time_sec

Zongwei Zhou's avatar
Zongwei Zhou committed
206
207
    # Warmup means the number of logged step time entries that are excluded in
    # performance report. Default to exclude 1 FLAGS.log_steps time.
208
209
210
211
212
    super(Resnet50CtlBenchmarkBase, self)._report_benchmark(
        stats,
        wall_time_sec,
        total_batch_size=FLAGS.batch_size,
        log_steps=FLAGS.log_steps,
Zongwei Zhou's avatar
Zongwei Zhou committed
213
        warmup=1,
A. Unique TensorFlower's avatar
A. Unique TensorFlower committed
214
        start_time_sec=start_time_sec)
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230

  def benchmark_1_gpu_no_dist_strat(self):
    """Test Keras model with 1 GPU, no distribution strategy."""
    self._setup()

    FLAGS.num_gpus = 1
    FLAGS.distribution_strategy = 'off'
    FLAGS.model_dir = self._get_model_dir('benchmark_1_gpu_no_dist_strat')
    FLAGS.batch_size = 128
    self._run_and_report_benchmark()

  def benchmark_1_gpu(self):
    """Test Keras model with 1 GPU."""
    self._setup()

    FLAGS.num_gpus = 1
231
    FLAGS.distribution_strategy = 'one_device'
232
233
234
235
    FLAGS.model_dir = self._get_model_dir('benchmark_1_gpu')
    FLAGS.batch_size = 128
    self._run_and_report_benchmark()

236
237
238
239
240
241
242
243
244
245
246
  def benchmark_1_gpu_fp16(self):
    """Test Keras model with 1 GPU with tf.keras mixed precision."""
    self._setup()

    FLAGS.num_gpus = 1
    FLAGS.distribution_strategy = 'one_device'
    FLAGS.model_dir = self._get_model_dir('benchmark_1_gpu_fp16')
    FLAGS.batch_size = 256
    FLAGS.dtype = 'fp16'
    self._run_and_report_benchmark()

247
248
249
250
251
  def benchmark_1_gpu_amp(self):
    """Test Keras model with 1 GPU with automatic mixed precision."""
    self._setup()

    FLAGS.num_gpus = 1
252
    FLAGS.distribution_strategy = 'one_device'
253
    FLAGS.model_dir = self._get_model_dir('benchmark_1_gpu_amp')
254
    FLAGS.batch_size = 256
255
256
257
258
259
260
261
262
263
    FLAGS.dtype = 'fp16'
    FLAGS.fp16_implementation = 'graph_rewrite'
    self._run_and_report_benchmark()

  def benchmark_xla_1_gpu_amp(self):
    """Test Keras model with XLA and 1 GPU with automatic mixed precision."""
    self._setup()

    FLAGS.num_gpus = 1
264
    FLAGS.distribution_strategy = 'one_device'
265
    FLAGS.model_dir = self._get_model_dir('benchmark_xla_1_gpu_amp')
266
    FLAGS.batch_size = 256
267
268
269
270
271
    FLAGS.dtype = 'fp16'
    FLAGS.fp16_implementation = 'graph_rewrite'
    FLAGS.enable_xla = True
    self._run_and_report_benchmark()

272
273
274
275
276
  def benchmark_1_gpu_eager(self):
    """Test Keras model with 1 GPU in pure eager mode."""
    self._setup()

    FLAGS.num_gpus = 1
277
    FLAGS.distribution_strategy = 'one_device'
278
    FLAGS.model_dir = self._get_model_dir('benchmark_1_gpu_eager')
279
    FLAGS.batch_size = 120
280
    FLAGS.use_tf_function = False
281
    FLAGS.use_tf_while_loop = False
282
    FLAGS.single_l2_loss_op = True
283
284
    self._run_and_report_benchmark()

285
286
287
288
289
290
291
  def benchmark_1_gpu_fp16_eager(self):
    """Test Keras model with 1 GPU with fp16 and pure eager mode."""
    self._setup()

    FLAGS.num_gpus = 1
    FLAGS.distribution_strategy = 'one_device'
    FLAGS.model_dir = self._get_model_dir('benchmark_1_gpu_fp16_eager')
292
    FLAGS.batch_size = 240
293
294
    FLAGS.dtype = 'fp16'
    FLAGS.use_tf_function = False
295
    FLAGS.use_tf_while_loop = False
296
297
298
    FLAGS.single_l2_loss_op = True
    self._run_and_report_benchmark()

299
300
301
302
303
  def benchmark_8_gpu(self):
    """Test Keras model with 8 GPUs."""
    self._setup()

    FLAGS.num_gpus = 8
304
    FLAGS.distribution_strategy = 'mirrored'
305
306
307
308
    FLAGS.model_dir = self._get_model_dir('benchmark_8_gpu')
    FLAGS.batch_size = 128 * 8  # 8 GPUs
    self._run_and_report_benchmark()

309
310
311
312
313
314
315
316
317
318
319
  def benchmark_8_gpu_fp16(self):
    """Test Keras model with 8 GPUs with tf.keras mixed precision."""
    self._setup()

    FLAGS.num_gpus = 8
    FLAGS.distribution_strategy = 'mirrored'
    FLAGS.model_dir = self._get_model_dir('benchmark_8_gpu_fp16')
    FLAGS.batch_size = 256 * 8  # 8 GPUs
    FLAGS.dtype = 'fp16'
    self._run_and_report_benchmark()

Sai Ganesh Bandiatmakuri's avatar
Sai Ganesh Bandiatmakuri committed
320
321
322
323
324
325
  def benchmark_8_gpu_eager(self):
    """Test Keras model with 8 GPUs, eager, fp32."""
    self._setup()

    FLAGS.num_gpus = 8
    FLAGS.use_tf_function = False
326
    FLAGS.use_tf_while_loop = False
Sai Ganesh Bandiatmakuri's avatar
Sai Ganesh Bandiatmakuri committed
327
328
329
330
331
332
333
334
335
336
337
338
    FLAGS.distribution_strategy = 'mirrored'
    FLAGS.model_dir = self._get_model_dir('benchmark_8_gpu_eager')
    FLAGS.batch_size = 128
    self._run_and_report_benchmark()

  def benchmark_8_gpu_eager_fp16(self):
    """Test Keras model with 8 GPUs, eager, fp16."""
    self._setup()

    FLAGS.num_gpus = 8
    FLAGS.dtype = 'fp16'
    FLAGS.use_tf_function = False
339
    FLAGS.use_tf_while_loop = False
Sai Ganesh Bandiatmakuri's avatar
Sai Ganesh Bandiatmakuri committed
340
341
342
343
344
    FLAGS.distribution_strategy = 'mirrored'
    FLAGS.model_dir = self._get_model_dir('benchmark_8_gpu_eager_fp16')
    FLAGS.batch_size = 128
    self._run_and_report_benchmark()

345
346
347
348
349
  def benchmark_8_gpu_amp(self):
    """Test Keras model with 8 GPUs with automatic mixed precision."""
    self._setup()

    FLAGS.num_gpus = 8
350
    FLAGS.distribution_strategy = 'mirrored'
351
    FLAGS.model_dir = self._get_model_dir('benchmark_8_gpu_amp')
352
    FLAGS.batch_size = 256 * 8  # 8 GPUs
353
354
355
356
357
358
359
360
361
    FLAGS.dtype = 'fp16'
    FLAGS.fp16_implementation = 'graph_rewrite'
    self._run_and_report_benchmark()

  def benchmark_xla_8_gpu_amp(self):
    """Test Keras model with XLA and 8 GPUs with automatic mixed precision."""
    self._setup()

    FLAGS.num_gpus = 8
362
    FLAGS.distribution_strategy = 'mirrored'
363
    FLAGS.model_dir = self._get_model_dir('benchmark_xla_8_gpu_amp')
364
    FLAGS.batch_size = 256 * 8  # 8 GPUs
365
366
367
368
369
    FLAGS.dtype = 'fp16'
    FLAGS.fp16_implementation = 'graph_rewrite'
    FLAGS.enable_xla = True
    self._run_and_report_benchmark()

Zongwei Zhou's avatar
Zongwei Zhou committed
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
  def _set_df_common(self):
    FLAGS.steps_per_loop = 500
    FLAGS.train_epochs = 2
    FLAGS.train_steps = None
    FLAGS.skip_eval = True
    FLAGS.enable_eager = True
    FLAGS.enable_tensorboard = False
    FLAGS.distribution_strategy = 'tpu'
    FLAGS.report_accuracy_metrics = False
    FLAGS.log_steps = 50
    FLAGS.single_l2_loss_op = True
    FLAGS.use_tf_function = True
    FLAGS.enable_checkpoint_and_export = False

  def benchmark_2x2_tpu_bf16(self):
    self._setup()
    self._set_df_common()
    FLAGS.batch_size = 1024
    FLAGS.dtype = 'bf16'
    self._run_and_report_benchmark()

  def benchmark_4x4_tpu_bf16(self):
    self._setup()
    self._set_df_common()
    FLAGS.batch_size = 4096
    FLAGS.dtype = 'bf16'
    self._run_and_report_benchmark()

  def benchmark_8x16_tpu_bf16(self):
    self._setup()
    self._set_df_common()
    FLAGS.batch_size = 8192
    FLAGS.dtype = 'bf16'
    self._run_and_report_benchmark()

405
406
  def fill_report_object(self, stats):
    super(Resnet50CtlBenchmarkBase, self).fill_report_object(
407
        stats, total_batch_size=FLAGS.batch_size, log_steps=FLAGS.log_steps)
408
409
410
411
412
413
414
415
416
417


class Resnet50CtlBenchmarkSynth(Resnet50CtlBenchmarkBase):
  """Resnet50 synthetic benchmark tests."""

  def __init__(self, output_dir=None, root_data_dir=None, **kwargs):
    def_flags = {}
    def_flags['skip_eval'] = True
    def_flags['use_synthetic_data'] = True
    def_flags['train_steps'] = 110
Ruoxin Sang's avatar
Ruoxin Sang committed
418
    def_flags['steps_per_loop'] = 20
419
420
421
422
423
424
425
426
427
428
429
430
    def_flags['log_steps'] = 10

    super(Resnet50CtlBenchmarkSynth, self).__init__(
        output_dir=output_dir, default_flags=def_flags)


class Resnet50CtlBenchmarkReal(Resnet50CtlBenchmarkBase):
  """Resnet50 real data benchmark tests."""

  def __init__(self, output_dir=None, root_data_dir=None, **kwargs):
    def_flags = {}
    def_flags['skip_eval'] = True
Zongwei Zhou's avatar
Zongwei Zhou committed
431
    def_flags['data_dir'] = os.path.join(root_data_dir, 'imagenet')
432
    def_flags['train_steps'] = 110
Ruoxin Sang's avatar
Ruoxin Sang committed
433
    def_flags['steps_per_loop'] = 20
434
435
436
437
438
    def_flags['log_steps'] = 10

    super(Resnet50CtlBenchmarkReal, self).__init__(
        output_dir=output_dir, default_flags=def_flags)

439

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