Google I / O 18-20 मई को लौटता है! जगह आरक्षित करें और अपना शेड्यूल बनाएं अभी रजिस्टर करें
इस पेज का अनुवाद Cloud Translation API से किया गया है.
Switch to English

केरस के साथ प्रशिक्षण वितरित किया

TensorFlow.org पर देखें Google Colab में चलाएं GitHub पर स्रोत देखें नोटबुक डाउनलोड करें

अवलोकन

tf.distribute.Strategy API कई प्रशिक्षण इकाइयों में आपके प्रशिक्षण को वितरित करने के लिए एक अमूर्तता प्रदान करता है। लक्ष्य उपयोगकर्ताओं को कम से कम परिवर्तनों के साथ मौजूदा मॉडल और प्रशिक्षण कोड का उपयोग करके वितरित प्रशिक्षण को सक्षम करने की अनुमति देना है।

यह ट्यूटोरियल tf.distribute.MirroredStrategy का उपयोग करता है, जो एक मशीन पर कई GPU पर तुल्यकालिक प्रशिक्षण के साथ इन-ग्राफ प्रतिकृति करता है। अनिवार्य रूप से, यह प्रत्येक प्रोसेसर के लिए मॉडल के सभी चर को कॉपी करता है। फिर, यह सभी प्रोसेसरों से ग्रेडिएंट को संयोजित करने के लिए ऑल-कम का उपयोग करता है और मॉडल की सभी प्रतियों के लिए संयुक्त मूल्य को लागू करता है।

MirroredStrategy कई वितरण TensorFlow कोर में उपलब्ध रणनीति से एक है। आप वितरण रणनीति गाइड में अधिक रणनीतियों के बारे में पढ़ सकते हैं।

करेस एपीआई

यह उदाहरण मॉडल और प्रशिक्षण लूप बनाने के लिए tf.keras API का उपयोग करता है। कस्टम प्रशिक्षण लूप के लिए, प्रशिक्षण लूप ट्यूटोरियल के साथ tf.distribute.Strategy देखें।

आयात निर्भरता

# Import TensorFlow and TensorFlow Datasets

import tensorflow_datasets as tfds
import tensorflow as tf

import os
print(tf.__version__)
2.4.1

डेटासेट डाउनलोड करें

MNIST डेटासेट डाउनलोड करें और इसे TensorFlow Datasets से लोड करें। यह tf.data प्रारूप में डेटासेट देता है।

with_info को True सेट करने से संपूर्ण डेटासेट के लिए मेटाडेटा शामिल है, जिसे यहाँ info सहेजा जा रहा है। अन्य बातों के अलावा, इस मेटाडेटा ऑब्जेक्ट में ट्रेन की संख्या और परीक्षण उदाहरण शामिल हैं।

datasets, info = tfds.load(name='mnist', with_info=True, as_supervised=True)

mnist_train, mnist_test = datasets['train'], datasets['test']

वितरण रणनीति को परिभाषित करें

एक MirroredStrategy ऑब्जेक्ट बनाएं। यह वितरण को संभालेगा, और आपके मॉडल को बनाने के लिए एक संदर्भ प्रबंधक ( tf.distribute.MirroredStrategy.scope ) प्रदान करता है।

strategy = tf.distribute.MirroredStrategy()
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)
print('Number of devices: {}'.format(strategy.num_replicas_in_sync))
Number of devices: 1

सेटअप इनपुट पाइपलाइन

कई GPU के साथ एक मॉडल को प्रशिक्षित करते समय, आप बैच आकार को बढ़ाकर अतिरिक्त कंप्यूटिंग शक्ति का प्रभावी ढंग से उपयोग कर सकते हैं। सामान्य तौर पर, सबसे बड़े बैच आकार का उपयोग करें जो GPU मेमोरी को फिट करता है, और तदनुसार सीखने की दर को ट्यून करता है।

# You can also do info.splits.total_num_examples to get the total
# number of examples in the dataset.

num_train_examples = info.splits['train'].num_examples
num_test_examples = info.splits['test'].num_examples

BUFFER_SIZE = 10000

BATCH_SIZE_PER_REPLICA = 64
BATCH_SIZE = BATCH_SIZE_PER_REPLICA * strategy.num_replicas_in_sync

पिक्सेल मान, जो 0-255 हैं, को 0-1 की सीमा तक सामान्य किया जाना चाहिए । एक समारोह में इस पैमाने को परिभाषित करें।

def scale(image, label):
  image = tf.cast(image, tf.float32)
  image /= 255

  return image, label

इस फ़ंक्शन को प्रशिक्षण और परीक्षण डेटा पर लागू करें, प्रशिक्षण डेटा को फेरबदल करें, और इसे प्रशिक्षण के लिए बैच दें । सूचना हम प्रदर्शन को बेहतर बनाने के लिए प्रशिक्षण डेटा का इन-मेमोरी कैश भी रख रहे हैं।

train_dataset = mnist_train.map(scale).cache().shuffle(BUFFER_SIZE).batch(BATCH_SIZE)
eval_dataset = mnist_test.map(scale).batch(BATCH_SIZE)

मॉडल बनाएं

Keras मॉडल बनाएँ और संकलित करें strategy.scope के संदर्भ में।

with strategy.scope():
  model = tf.keras.Sequential([
      tf.keras.layers.Conv2D(32, 3, activation='relu', input_shape=(28, 28, 1)),
      tf.keras.layers.MaxPooling2D(),
      tf.keras.layers.Flatten(),
      tf.keras.layers.Dense(64, activation='relu'),
      tf.keras.layers.Dense(10)
  ])

  model.compile(loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
                optimizer=tf.keras.optimizers.Adam(),
                metrics=['accuracy'])
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).

कॉलबैक को परिभाषित करें

यहाँ उपयोग की जाने वाली कॉलबैक हैं:

  • TensorBoard : यह कॉलबैक TensorBoard के लिए एक लॉग लिखता है जो आपको ग्राफ़ की कल्पना करने की अनुमति देता है।
  • मॉडल चेकपॉइंट : यह कॉलबैक प्रत्येक युग के बाद मॉडल को बचाता है।
  • लर्निंग रेट शेड्यूलर : इस कॉलबैक का उपयोग करके, आप प्रत्येक युग / बैच के बाद सीखने की दर को बदल सकते हैं।

उदाहरण के लिए, नोटबुक में सीखने की दर प्रदर्शित करने के लिए एक प्रिंट कॉलबैक जोड़ें।

# Define the checkpoint directory to store the checkpoints

checkpoint_dir = './training_checkpoints'
# Name of the checkpoint files
checkpoint_prefix = os.path.join(checkpoint_dir, "ckpt_{epoch}")
# Function for decaying the learning rate.
# You can define any decay function you need.
def decay(epoch):
  if epoch < 3:
    return 1e-3
  elif epoch >= 3 and epoch < 7:
    return 1e-4
  else:
    return 1e-5
# Callback for printing the LR at the end of each epoch.
class PrintLR(tf.keras.callbacks.Callback):
  def on_epoch_end(self, epoch, logs=None):
    print('\nLearning rate for epoch {} is {}'.format(epoch + 1,
                                                      model.optimizer.lr.numpy()))
callbacks = [
    tf.keras.callbacks.TensorBoard(log_dir='./logs'),
    tf.keras.callbacks.ModelCheckpoint(filepath=checkpoint_prefix,
                                       save_weights_only=True),
    tf.keras.callbacks.LearningRateScheduler(decay),
    PrintLR()
]

ट्रेन करें और मूल्यांकन करें

अब, मॉडल को सामान्य तरीके से प्रशिक्षित करें, मॉडल पर fit और ट्यूटोरियल की शुरुआत में बनाए गए डेटासेट में पास करें। यह चरण वही है जो आप प्रशिक्षण वितरित कर रहे हैं या नहीं।

model.fit(train_dataset, epochs=12, callbacks=callbacks)
Epoch 1/12
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
5/938 [..............................] - ETA: 11s - loss: 2.2256 - accuracy: 0.2527    WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0036s vs `on_train_batch_end` time: 0.0062s). Check your callbacks.
WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0036s vs `on_train_batch_end` time: 0.0062s). Check your callbacks.
938/938 [==============================] - 18s 4ms/step - loss: 0.3872 - accuracy: 0.8928

Learning rate for epoch 1 is 0.0010000000474974513
Epoch 2/12
938/938 [==============================] - 3s 3ms/step - loss: 0.0713 - accuracy: 0.9787

Learning rate for epoch 2 is 0.0010000000474974513
Epoch 3/12
938/938 [==============================] - 3s 3ms/step - loss: 0.0512 - accuracy: 0.9855

Learning rate for epoch 3 is 0.0010000000474974513
Epoch 4/12
938/938 [==============================] - 3s 3ms/step - loss: 0.0276 - accuracy: 0.9919

Learning rate for epoch 4 is 9.999999747378752e-05
Epoch 5/12
938/938 [==============================] - 3s 3ms/step - loss: 0.0251 - accuracy: 0.9930

Learning rate for epoch 5 is 9.999999747378752e-05
Epoch 6/12
938/938 [==============================] - 3s 3ms/step - loss: 0.0225 - accuracy: 0.9940

Learning rate for epoch 6 is 9.999999747378752e-05
Epoch 7/12
938/938 [==============================] - 3s 3ms/step - loss: 0.0204 - accuracy: 0.9948

Learning rate for epoch 7 is 9.999999747378752e-05
Epoch 8/12
938/938 [==============================] - 3s 3ms/step - loss: 0.0165 - accuracy: 0.9959

Learning rate for epoch 8 is 9.999999747378752e-06
Epoch 9/12
938/938 [==============================] - 3s 3ms/step - loss: 0.0180 - accuracy: 0.9955

Learning rate for epoch 9 is 9.999999747378752e-06
Epoch 10/12
938/938 [==============================] - 3s 3ms/step - loss: 0.0187 - accuracy: 0.9955

Learning rate for epoch 10 is 9.999999747378752e-06
Epoch 11/12
938/938 [==============================] - 3s 3ms/step - loss: 0.0177 - accuracy: 0.9959

Learning rate for epoch 11 is 9.999999747378752e-06
Epoch 12/12
938/938 [==============================] - 3s 3ms/step - loss: 0.0170 - accuracy: 0.9961

Learning rate for epoch 12 is 9.999999747378752e-06
<tensorflow.python.keras.callbacks.History at 0x7fa6a5c1f9e8>

जैसा कि आप नीचे देख सकते हैं, चौकियों को बचाया जा रहा है।

# check the checkpoint directory
ls {checkpoint_dir}
checkpoint           ckpt_4.data-00000-of-00001
ckpt_1.data-00000-of-00001   ckpt_4.index
ckpt_1.index             ckpt_5.data-00000-of-00001
ckpt_10.data-00000-of-00001  ckpt_5.index
ckpt_10.index            ckpt_6.data-00000-of-00001
ckpt_11.data-00000-of-00001  ckpt_6.index
ckpt_11.index            ckpt_7.data-00000-of-00001
ckpt_12.data-00000-of-00001  ckpt_7.index
ckpt_12.index            ckpt_8.data-00000-of-00001
ckpt_2.data-00000-of-00001   ckpt_8.index
ckpt_2.index             ckpt_9.data-00000-of-00001
ckpt_3.data-00000-of-00001   ckpt_9.index
ckpt_3.index

यह देखने के लिए कि मॉडल कैसा प्रदर्शन करता है, नवीनतम चेकपॉइंट लोड करें और परीक्षण डेटा पर कॉल evaluate करें।

उचित डेटासेट का उपयोग evaluate से पहले evaluate को कॉल करें।

model.load_weights(tf.train.latest_checkpoint(checkpoint_dir))

eval_loss, eval_acc = model.evaluate(eval_dataset)

print('Eval loss: {}, Eval Accuracy: {}'.format(eval_loss, eval_acc))
157/157 [==============================] - 3s 5ms/step - loss: 0.0382 - accuracy: 0.9871
Eval loss: 0.03821386396884918, Eval Accuracy: 0.9871000051498413

आउटपुट को देखने के लिए, आप TensorBoard लॉग को टर्मिनल पर डाउनलोड और देख सकते हैं।

$ tensorboard --logdir=path/to/log-directory
ls -sh ./logs
total 4.0K
4.0K train

SavedModel को निर्यात करें

प्लेटफ़ॉर्म-अज्ञेयवादी SavedModel प्रारूप में ग्राफ़ और चर निर्यात करें। आपका मॉडल सहेजे जाने के बाद, आप इसे स्कोप के साथ या उसके बिना लोड कर सकते हैं।

path = 'saved_model/'
model.save(path, save_format='tf')
INFO:tensorflow:Assets written to: saved_model/assets
INFO:tensorflow:Assets written to: saved_model/assets

बिना strategy.scope के मॉडल को लोड करें।

unreplicated_model = tf.keras.models.load_model(path)

unreplicated_model.compile(
    loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
    optimizer=tf.keras.optimizers.Adam(),
    metrics=['accuracy'])

eval_loss, eval_acc = unreplicated_model.evaluate(eval_dataset)

print('Eval loss: {}, Eval Accuracy: {}'.format(eval_loss, eval_acc))
157/157 [==============================] - 1s 3ms/step - loss: 0.0364 - accuracy: 0.9883
Eval loss: 0.03821386396884918, Eval Accuracy: 0.9871000051498413

मॉडल को strategy.scope साथ लोड करें।

with strategy.scope():
  replicated_model = tf.keras.models.load_model(path)
  replicated_model.compile(loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
                           optimizer=tf.keras.optimizers.Adam(),
                           metrics=['accuracy'])

  eval_loss, eval_acc = replicated_model.evaluate(eval_dataset)
  print ('Eval loss: {}, Eval Accuracy: {}'.format(eval_loss, eval_acc))
157/157 [==============================] - 3s 4ms/step - loss: 0.0364 - accuracy: 0.9883
Eval loss: 0.03821386396884918, Eval Accuracy: 0.9871000051498413

उदाहरण और ट्यूटोरियल

यहाँ केरेस फिट / संकलन के साथ वितरण रणनीति का उपयोग करने के कुछ उदाहरण दिए गए हैं:

  1. ट्रांसफार्मर उदाहरण को tf.distribute.MirroredStrategy का उपयोग करके प्रशिक्षित किया tf.distribute.MirroredStrategy
  2. NCF उदाहरण tf.distribute.MirroredStrategy का उपयोग करके प्रशिक्षित।

वितरण रणनीति गाइड में सूचीबद्ध अधिक उदाहरण

अगला कदम