рд╡реНрдпрд╡рд╕реНрдерд╛ рдЬрд╛рдирдХрд╛рд░реА
Have I written custom code (as opposed to using a stock example script provided in TensorFlow):
OS Platform and Distribution: Ubuntu 18.04
TensorFlow installed from (source or binary): pip install tensorflow-gpu
TensorFlow version (use command below): 2.0
Python version: 3.6.9
CUDA/cuDNN version: 10/7.6.4.38
GPU model and memory: Tesla P4 8G
рд╡рд░реНрддрдорд╛рди рд╡реНрдпрд╡рд╣рд╛рд░ рдХрд╛ рд╡рд░реНрдгрди рдХрд░реЗрдВ
рдореИрдВ рдиреАрдЪреЗ рд╡рд░реНрдгрд┐рдд рдХреЛрдб рдЪрд▓рд╛рддрд╛ рд╣реВрдВ:
рдЯреЗрд╕реНрдЯ 1: (рджреЛ рдорд╢реАрди)
os.environ['TF_CONFIG'] = json.dumps({
'рдХреНрд▓рд╕реНрдЯрд░': {
'рдХрд╛рд░реНрдпрдХрд░реНрддрд╛': ["рд╕рд░реНрд╡рд░1:12345", "рд╕рд░реНрд╡рд░2:12345"]
},
'рдХрд╛рд░реНрдп': {'рдкреНрд░рдХрд╛рд░': 'рдХрд╛рд░реНрдпрдХрд░реНрддрд╛', 'рд╕реВрдЪрдХрд╛рдВрдХ': 0}
})
рджреВрд╕рд░реА рдорд╢реАрди рдореЗрдВ
os.environ['TF_CONFIG'] = json.dumps({
'рдХреНрд▓рд╕реНрдЯрд░': {
'рдХрд╛рд░реНрдпрдХрд░реНрддрд╛': ["рд╕рд░реНрд╡рд░1:12345", "рд╕рд░реНрд╡рд░2:12345"]
},
'рдХрд╛рд░реНрдп': {'рдкреНрд░рдХрд╛рд░': 'рдХрд╛рд░реНрдпрдХрд░реНрддрд╛', 'рд╕реВрдЪрдХрд╛рдВрдХ': 1}
})
рдЬрдм рд╕реНрдХреНрд░рд┐рдкреНрдЯ рдкрд╣рд▓реЗ рдпреБрдЧ рдХреЛ рд╕рдВрд╕рд╛рдзрд┐рдд рдХрд░рдирд╛ рд╢реБрд░реВ рдХрд░рддреА рд╣реИ рддреЛ рдпрд╣ рдХреНрд░реИрд╢ рд╣реЛ рдЬрд╛рддреА рд╣реИ,
рдЕрдкреЗрдХреНрд╖рд┐рдд рд╡реНрдпрд╡рд╣рд╛рд░ рдХрд╛ рд╡рд░реНрдгрди рдХрд░реЗрдВ
15s/рдпреБрдЧ рдЗрддрдирд╛ рдзреАрдорд╛ рд╣реИ
рдЯреЗрд╕реНрдЯ 2: (рдПрдХ рдорд╢реАрди)
os.environ['TF_CONFIG'] = json.dumps({
'рдХреНрд▓рд╕реНрдЯрд░': {
'рдХрд╛рд░реНрдпрдХрд░реНрддрд╛': ["рд╕рд░реНрд╡рд░1:12345"]
},
'рдХрд╛рд░реНрдп': {'рдкреНрд░рдХрд╛рд░': 'рдХрд╛рд░реНрдпрдХрд░реНрддрд╛', 'рд╕реВрдЪрдХрд╛рдВрдХ': 0}
})
рдЕрдкреЗрдХреНрд╖рд┐рдд рд╡реНрдпрд╡рд╣рд╛рд░ рдХрд╛ рд╡рд░реНрдгрди рдХрд░реЗрдВ
5s/рдпреБрдЧ рдЙрдкрдпреЛрдЧ рд░рдгрдиреАрддрд┐ рдХреЗ рд╕рдорд╛рди = tf.distribute.MirroredStrategy() рдПрдХ GPU рдХрд╛рд░реНрдб
рдХреЛрдб
import ssl
import os
import json
import argparse
import time
import numpy as np
import tensorflow as tf
import tensorflow_datasets as tfds
ssl._create_default_https_context = ssl._create_unverified_context
def configure_cluster(worker_hosts=None, task_index=-1):
"""Set multi-worker cluster spec in TF_CONFIG environment variable.
Args:
worker_hosts: comma-separated list of worker ip:port pairs.
Returns:
Number of workers in the cluster.
"""
tf_config = json.loads(os.environ.get('TF_CONFIG', '{}'))
if tf_config:
num_workers = len(tf_config['cluster'].get('worker', []))
elif worker_hosts:
workers = worker_hosts.split(',')
num_workers = len(workers)
if num_workers > 1 and task_index < 0:
raise ValueError('Must specify task_index when number of workers > 1')
task_index = 0 if num_workers == 1 else task_index
os.environ['TF_CONFIG'] = json.dumps({
'cluster': {
'worker': workers
},
'task': {'type': 'worker', 'index': task_index}
})
else:
num_workers = 1
return num_workers
parser = argparse.ArgumentParser(description='TensorFlow Benchmark',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--num-epochs', type=int, default=5, help='input batch size')
parser.add_argument('--batch-size-per-replica', type=int, default=32, help='input batch size')
parser.add_argument('--worker-method', type=str, default="NCCL")
parser.add_argument('--worker-hosts', type=str, default="localhost:23456")
parser.add_argument('--worker-index', type=int, default=0)
args = parser.parse_args()
worker_num = configure_cluster(args.worker_hosts, args.worker_index)
batch_size = args.batch_size_per_replica * worker_num
print('Batch Size: %d' % batch_size)
gpus = tf.config.experimental.list_physical_devices('GPU')
print("Physical GPU Devices Num:", len(gpus))
for gpu in gpus:
tf.config.experimental.set_memory_growth(gpu, True)
if args.worker_method == "AUTO":
communication = tf.distribute.experimental.CollectiveCommunication.AUTO
elif args.worker_method == "RING":
communication = tf.distribute.experimental.CollectiveCommunication.RING
else:
communication = tf.distribute.experimental.CollectiveCommunication.NCCL
strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy(
communication=communication)
# logical_gpus = tf.config.experimental.list_logical_devices('GPU')
# print("Logical GPU Devices Num:", len(gpus))
def resize(image, label):
image = tf.image.resize(image, [128, 128]) / 255.0
return image, label
# if as_supervised is Trueя╝Мreturn image abd label
dataset, info = tfds.load("tf_flowers", split=tfds.Split.TRAIN, with_info=True, as_supervised=True)
dataset = dataset.map(resize).repeat().shuffle(1024).batch(batch_size)
# options = tf.data.Options()
# options.experimental_distribute.auto_shard = False
# dataset = dataset.with_options(options)
def build_and_compile_cnn_model():
model = tf.keras.Sequential([
tf.keras.layers.Conv2D(32, [3, 3], activation='relu'),
tf.keras.layers.Conv2D(64, [3, 3], activation='relu'),
tf.keras.layers.MaxPooling2D(pool_size=(2, 2)),
tf.keras.layers.Dropout(0.25),
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dropout(0.5),
tf.keras.layers.Dense(info.features['label'].num_classes, activation='softmax')
])
model.compile(
opt=tf.keras.optimizers.Adam(learning_rate=0.0001),
loss=tf.keras.losses.sparse_categorical_crossentropy,
metrics=[tf.keras.metrics.sparse_categorical_accuracy]
)
return model
with strategy.scope():
multi_worker_model = build_and_compile_cnn_model()
print("Now training the distributed model")
class TimeHistory(tf.keras.callbacks.Callback):
def on_train_begin(self, logs={}):
self.times = []
self.totaltime = time.time()
def on_train_end(self, logs={}):
self.totaltime = time.time() - self.totaltime
def on_epoch_begin(self, batch, logs={}):
self.epoch_time_start = time.time()
def on_epoch_end(self, batch, logs={}):
self.times.append(time.time() - self.epoch_time_start)
time_callback = TimeHistory()
steps_per_epoch = 100
print('Running benchmark...')
multi_worker_model.fit(dataset, steps_per_epoch=steps_per_epoch, epochs=args.num_epochs, callbacks=[time_callback])
per_epoch_time = np.mean(time_callback.times[1:])
print("per_epoch_time:", per_epoch_time)
img_sec = batch_size * steps_per_epoch / per_epoch_time
print("Result: {:.1f} pic/sec".format(img_sec))
рдЯреЗрд╕реНрдЯ 2 рдореЗрдВ: рдХреЗрд╡рд▓ 1 рдХрд╛рд░реНрдпрдХрд░реНрддрд╛, 440pic/рд╕реЗрдХрдВрдб batch_szie = 128я╝Й
рдЯреЗрд╕реНрдЯ 1 рдореЗрдВ: 2 рдХрд╛рд░реНрдпрдХрд░реНрддрд╛, 610 pic/sec batch_szie = 128*2я╝Й [рдЙрдореНрдореАрдж 440 *2 = 800+]
рдкреНрд░рд╢реНрди 1:
рдбрд┐рд╕реНрдЯреНрд░рд┐рдХреНрдЯ рдорд▓реНрдЯреАрд╡рд░реНрдХрд░ рдХреЗ рд╕рд╛рдердорд┐рд░рд░рдбрд╕реНрдЯреНрд░реЗрдЯреА рд╡рд░реНрдХрд░ рдирдВрдмрд░> 1, рдкреНрд░рд╢рд┐рдХреНрд╖рдг рдЗрддрдирд╛ рдзреАрдорд╛ рдХреНрдпреЛрдВ рд╣реИ
рдЙрдореНрдореАрдж
рдЖрдкрдХреЗ рдореЙрдбрд▓ рдХреЗ рдзреАрдореЗ рд╣реЛрдиреЗ рдХреЗ рдХрдИ рдХрд╛рд░рдг рд╣реЛ рд╕рдХрддреЗ рд╣реИрдВ: рдиреЗрдЯрд╡рд░реНрдХрд┐рдВрдЧ, рдбреЗрдЯрд╛ рдкрдврд╝рдирд╛, рдереНрд░реЗрдб рд╡рд┐рд╡рд╛рдж, рдЖрджрд┐ред рдЖрдк рдЕрдкрдиреЗ рдкреНрд░реЛрдЧреНрд░рд╛рдо рдХреЛ рдпрд╣ рджреЗрдЦрдиреЗ рдХреЗ рд▓рд┐рдП рдкреНрд░реЛрдлрд╛рдЗрд▓ рдХрд░ рд╕рдХрддреЗ рд╣реИрдВ рдХрд┐ рдХреМрди рд╕рд╛ рд╣рд┐рд╕реНрд╕рд╛ рдЕрдбрд╝рдЪрди рд╣реИ: https://www.tensorflow.org/tensorboard/tensorboard_profiling_keras
рдХреНрдпрд╛ рдЖрдк рдЕрдкрдиреА рд╕рдорд╕реНрдпрд╛ рдХреЗ рд╕рдорд╛рдзрд╛рди рд╕реЗ рд╕рдВрддреБрд╖реНрдЯ рд╣реИрдВ?
рд╣рд╛рдБ
рдирд╣реАрдВ рди
рдЕрдм рдмрдВрдж рд╣реЛ рд░рд╣рд╛ рд╣реИред рдпрджрд┐ рдЖрдк рдЕрдкрдиреА рдкреНрд░реЛрдлрд╝рд╛рдЗрд▓ рдкрд░ рд╕реНрдкрд╖реНрдЯ рд╕рдорд╕реНрдпрд╛рдПрдВ рджреЗрдЦрддреЗ рд╣реИрдВ, рддреЛ рдмреЗрдЭрд┐рдЭрдХ рдлрд┐рд░ рд╕реЗ рдЦреЛрд▓реЗрдВ рдпрд╛ рдПрдХ рдирдпрд╛ рдореБрджреНрджрд╛ рджрд░реНрдЬ рдХрд░реЗрдВред