अपने स्थानीय TensorFlow के लिए RSVP आज हर जगह घटना!
इस पेज का अनुवाद Cloud Translation API से किया गया है.
Switch to English

Tf.distribute.Strategy के साथ कस्टम प्रशिक्षण

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

यह ट्यूटोरियल दर्शाता है कि कस्टम ट्रेनिंग लूप्स के साथ tf.distribute.Strategy का उपयोग कैसे करें। हम फैशन MNIST डेटासेट पर एक सरल CNN मॉडल प्रशिक्षित करेंगे। फैशन MNIST डेटासेट में 2800 28 आकार की 60000 ट्रेन छवियां और 28 28 आकार के 10000 परीक्षण चित्र हैं।

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

# Import TensorFlow
import tensorflow as tf

# Helper libraries
import numpy as np
import os

print(tf.__version__)
2.3.0

फैशन MNIST डेटासेट डाउनलोड करें

fashion_mnist = tf.keras.datasets.fashion_mnist

(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()

# Adding a dimension to the array -> new shape == (28, 28, 1)
# We are doing this because the first layer in our model is a convolutional
# layer and it requires a 4D input (batch_size, height, width, channels).
# batch_size dimension will be added later on.
train_images = train_images[..., None]
test_images = test_images[..., None]

# Getting the images in [0, 1] range.
train_images = train_images / np.float32(255)
test_images = test_images / np.float32(255)
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-labels-idx1-ubyte.gz
32768/29515 [=================================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-images-idx3-ubyte.gz
26427392/26421880 [==============================] - 1s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-labels-idx1-ubyte.gz
8192/5148 [===============================================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-images-idx3-ubyte.gz
4423680/4422102 [==============================] - 1s 0us/step

चर और ग्राफ वितरित करने के लिए एक रणनीति बनाएं

tf.distribute.MirroredStrategy रणनीति कैसे काम करती है?

  • सभी चर और मॉडल ग्राफ प्रतिकृतियों पर दोहराया गया है।
  • इनपुट समान रूप से प्रतिकृतियों में वितरित किया जाता है।
  • प्रत्येक प्रतिकृति को प्राप्त इनपुट के लिए नुकसान और ग्रेडिएंट की गणना करता है।
  • ग्रेडिएंट सभी प्रतिकृतियों को संक्षेप में समेट कर सम्‍मिलित हैं।
  • सिंक के बाद, एक ही अद्यतन प्रत्येक प्रतिकृति पर चर की प्रतियों के लिए किया जाता है।
# If the list of devices is not specified in the
# `tf.distribute.MirroredStrategy` constructor, it will be auto-detected.
strategy = tf.distribute.MirroredStrategy()
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

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

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

BUFFER_SIZE = len(train_images)

BATCH_SIZE_PER_REPLICA = 64
GLOBAL_BATCH_SIZE = BATCH_SIZE_PER_REPLICA * strategy.num_replicas_in_sync

EPOCHS = 10

डेटासेट बनाएँ और उन्हें वितरित करें:

train_dataset = tf.data.Dataset.from_tensor_slices((train_images, train_labels)).shuffle(BUFFER_SIZE).batch(GLOBAL_BATCH_SIZE) 
test_dataset = tf.data.Dataset.from_tensor_slices((test_images, test_labels)).batch(GLOBAL_BATCH_SIZE) 

train_dist_dataset = strategy.experimental_distribute_dataset(train_dataset)
test_dist_dataset = strategy.experimental_distribute_dataset(test_dataset)

मॉडल बनाएं

tf.keras.Sequential का उपयोग करके एक मॉडल बनाएं। ऐसा करने के लिए आप मॉडल सबक्लासिंग एपीआई का भी उपयोग कर सकते हैं।

def create_model():
  model = tf.keras.Sequential([
      tf.keras.layers.Conv2D(32, 3, activation='relu'),
      tf.keras.layers.MaxPooling2D(),
      tf.keras.layers.Conv2D(64, 3, activation='relu'),
      tf.keras.layers.MaxPooling2D(),
      tf.keras.layers.Flatten(),
      tf.keras.layers.Dense(64, activation='relu'),
      tf.keras.layers.Dense(10)
    ])

  return model
# Create a checkpoint directory to store the checkpoints.
checkpoint_dir = './training_checkpoints'
checkpoint_prefix = os.path.join(checkpoint_dir, "ckpt")

नुकसान फ़ंक्शन को परिभाषित करें

आम तौर पर, एक मशीन पर 1 जीपीयू / सीपीयू के साथ, नुकसान को इनपुट के बैच में उदाहरणों की संख्या से विभाजित किया जाता है।

तो, tf.distribute.Strategy का उपयोग करते समय नुकसान की गणना कैसे की जानी चाहिए?

  • एक उदाहरण के लिए, मान लें कि आपके पास 4 जीपीयू और 64 के बैच का आकार है। इनपुट का एक बैच प्रतिकृति (4 जीपीयू) में वितरित किया जाता है, प्रत्येक प्रतिकृति का आकार 16 का इनपुट मिलता है।

  • प्रत्येक प्रतिकृति पर मॉडल अपने संबंधित इनपुट के साथ आगे पास करता है और नुकसान की गणना करता है। अब, अपने संबंधित इनपुट (BATCH_SIZE_PER_REPLICA = 16) में उदाहरणों की संख्या से नुकसान को विभाजित करने के बजाय, नुकसान को GLOBAL_BATCH_SIZE (64) से विभाजित किया जाना चाहिए।

यह क्यों?

  • ऐसा करने की आवश्यकता है क्योंकि प्रत्येक प्रतिकृति पर ग्रेडिएंट्स की गणना करने के बाद, उन्हें उनके द्वारा संक्षेप में प्रतिकृतियों में सिंक किया जाता है।

TensorFlow में यह कैसे करें?

  • यदि आप एक कस्टम ट्रेनिंग लूप लिख रहे हैं, तो इस ट्यूटोरियल में, आपको प्रति उदाहरण हानि का योग करना चाहिए और GLOBAL_BATCH_SIZE: scale_loss = tf.reduce_sum(loss) * (1. / GLOBAL_BATCH_SIZE) से योग को विभाजित करना चाहिए या आप tf.nn.compute_average_loss उपयोग कर सकते हैं tf.nn.compute_average_loss जो प्रति उदाहरण हानि, वैकल्पिक नमूना भार, और GLOBAL_BATCH_SIZE को तर्क के रूप में लेता है और स्केल की गई हानि लौटाता है।

  • यदि आप अपने मॉडल में नियमितीकरण घाटे का उपयोग कर रहे हैं, तो आपको प्रतिकृतियों की संख्या के आधार पर नुकसान के मान को मापना होगा। आप tf.nn.scale_regularization_loss फ़ंक्शन का उपयोग करके ऐसा कर सकते हैं।

  • tf.reduce_mean का उपयोग करने की अनुशंसा नहीं की जाती है। ऐसा करने से प्रति प्रतिकृति बैच आकार के हिसाब से नुकसान का बंटवारा होता है जो अलग-अलग चरणों में भिन्न हो सकता है।

  • यह कमी और स्केलिंग keras में स्वचालित रूप से किया जाता है model.compile और model.fit

  • यदिtf.keras.losses वर्गों का उपयोग कियाtf.keras.losses (जैसा कि नीचे दिए गए उदाहरण में है), नुकसान में कमी को स्पष्ट रूप से NONE या SUM एक होने के लिए निर्दिष्ट करने की आवश्यकता है। AUTO और SUM_OVER_BATCH_SIZE को tf.distribute.Strategy साथ उपयोग करने पर अस्वीकृत कर दिया जाता है। AUTO को अस्वीकृत कर दिया गया है क्योंकि उपयोगकर्ता को स्पष्ट रूप से सोचना चाहिए कि वे वितरित मामले में यह सुनिश्चित करना चाहते हैं कि यह किस कमी के कारण सही है। SUM_OVER_BATCH_SIZE को अस्वीकृत कर दिया गया है, क्योंकि वर्तमान में यह प्रति प्रतिकृति बैच आकार से विभाजित होगा, और उपयोगकर्ता को प्रतिकृतियों की संख्या से विभाजित करना छोड़ देगा, जो याद SUM_OVER_BATCH_SIZE आसान हो सकता है। इसलिए इसके बजाय हम पूछते हैं कि उपयोगकर्ता स्वयं कमी स्पष्ट रूप से करता है।

  • यदि labels बहु-आयामी है, तो प्रत्येक नमूने में तत्वों की संख्या के पार per_example_loss औसत करें। उदाहरण के लिए, यदि predictions का आकार है (batch_size, H, W, n_classes) और labels है (batch_size, H, W) (batch_size, H, W, n_classes) (batch_size, H, W) , तो आपको per_example_loss को अपडेट करने की आवश्यकता होगी: per_example_loss /= tf.cast(tf.reduce_prod(tf.shape(labels)[1:]), tf.float32)

with strategy.scope():
  # Set reduction to `none` so we can do the reduction afterwards and divide by
  # global batch size.
  loss_object = tf.keras.losses.SparseCategoricalCrossentropy(
      from_logits=True,
      reduction=tf.keras.losses.Reduction.NONE)
  def compute_loss(labels, predictions):
    per_example_loss = loss_object(labels, predictions)
    return tf.nn.compute_average_loss(per_example_loss, global_batch_size=GLOBAL_BATCH_SIZE)

नुकसान और सटीकता को ट्रैक करने के लिए मैट्रिक्स को परिभाषित करें

ये मीट्रिक परीक्षण हानि और प्रशिक्षण और परीक्षण सटीकता को ट्रैक करते हैं। आप किसी भी समय संचित आँकड़ों को प्राप्त करने के लिए .result() का उपयोग कर सकते हैं।

with strategy.scope():
  test_loss = tf.keras.metrics.Mean(name='test_loss')

  train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(
      name='train_accuracy')
  test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(
      name='test_accuracy')

प्रशिक्षण पाश

# model, optimizer, and checkpoint must be created under `strategy.scope`.
with strategy.scope():
  model = create_model()

  optimizer = tf.keras.optimizers.Adam()

  checkpoint = tf.train.Checkpoint(optimizer=optimizer, model=model)
def train_step(inputs):
  images, labels = inputs

  with tf.GradientTape() as tape:
    predictions = model(images, training=True)
    loss = compute_loss(labels, predictions)

  gradients = tape.gradient(loss, model.trainable_variables)
  optimizer.apply_gradients(zip(gradients, model.trainable_variables))

  train_accuracy.update_state(labels, predictions)
  return loss 

def test_step(inputs):
  images, labels = inputs

  predictions = model(images, training=False)
  t_loss = loss_object(labels, predictions)

  test_loss.update_state(t_loss)
  test_accuracy.update_state(labels, predictions)
# `run` replicates the provided computation and runs it
# with the distributed input.
@tf.function
def distributed_train_step(dataset_inputs):
  per_replica_losses = strategy.run(train_step, args=(dataset_inputs,))
  return strategy.reduce(tf.distribute.ReduceOp.SUM, per_replica_losses,
                         axis=None)

@tf.function
def distributed_test_step(dataset_inputs):
  return strategy.run(test_step, args=(dataset_inputs,))

for epoch in range(EPOCHS):
  # TRAIN LOOP
  total_loss = 0.0
  num_batches = 0
  for x in train_dist_dataset:
    total_loss += distributed_train_step(x)
    num_batches += 1
  train_loss = total_loss / num_batches

  # TEST LOOP
  for x in test_dist_dataset:
    distributed_test_step(x)

  if epoch % 2 == 0:
    checkpoint.save(checkpoint_prefix)

  template = ("Epoch {}, Loss: {}, Accuracy: {}, Test Loss: {}, "
              "Test Accuracy: {}")
  print (template.format(epoch+1, train_loss,
                         train_accuracy.result()*100, test_loss.result(),
                         test_accuracy.result()*100))

  test_loss.reset_states()
  train_accuracy.reset_states()
  test_accuracy.reset_states()
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/data/ops/multi_device_iterator_ops.py:601: get_next_as_optional (from tensorflow.python.data.ops.iterator_ops) is deprecated and will be removed in a future version.
Instructions for updating:
Use `tf.data.Iterator.get_next_as_optional()` instead.
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',).
Epoch 1, Loss: 0.50295090675354, Accuracy: 82.1116714477539, Test Loss: 0.3852590322494507, Test Accuracy: 86.5999984741211
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',).
Epoch 2, Loss: 0.32958829402923584, Accuracy: 88.20333862304688, Test Loss: 0.3391425311565399, Test Accuracy: 87.6500015258789
Epoch 3, Loss: 0.2872008979320526, Accuracy: 89.57167053222656, Test Loss: 0.2974696457386017, Test Accuracy: 89.31000518798828
Epoch 4, Loss: 0.255713552236557, Accuracy: 90.58499908447266, Test Loss: 0.2988712787628174, Test Accuracy: 89.31999969482422
Epoch 5, Loss: 0.23122134804725647, Accuracy: 91.41667175292969, Test Loss: 0.27742496132850647, Test Accuracy: 89.99000549316406
Epoch 6, Loss: 0.212575763463974, Accuracy: 92.17333221435547, Test Loss: 0.2573488652706146, Test Accuracy: 90.75
Epoch 7, Loss: 0.1963273137807846, Accuracy: 92.77166748046875, Test Loss: 0.2587501108646393, Test Accuracy: 90.66000366210938
Epoch 8, Loss: 0.1779220998287201, Accuracy: 93.46666717529297, Test Loss: 0.267805814743042, Test Accuracy: 90.55999755859375
Epoch 9, Loss: 0.16410504281520844, Accuracy: 93.91333770751953, Test Loss: 0.25632956624031067, Test Accuracy: 91.00999450683594
Epoch 10, Loss: 0.14829590916633606, Accuracy: 94.47833251953125, Test Loss: 0.25820475816726685, Test Accuracy: 91.00999450683594

उपरोक्त उदाहरण में ध्यान देने योग्य बातें:

  • हम निर्माण for x in ... का उपयोग करके train_dist_dataset और test_dist_dataset पर पुनरावृत्ति कर रहे हैं।
  • बढ़ाया नुकसान की वापसी मान है distributed_train_step । यह मान tf.distribute.Strategy.reduce कॉल का उपयोग करके प्रतिकृतियों में एकत्रित किया जाता है और फिर tf.distribute.Strategy.reduce कॉल के वापसी मूल्य को tf.distribute.Strategy.reduce बैचों में tf.distribute.Strategy.reduce है।
  • tf.keras.Metrics को train_step और test_step अंदर अपडेट किया जाना चाहिए जिसे tf.distribute.Strategy.run द्वारा निष्पादित किया जाता है। * tf.distribute.Strategy.run रणनीति में प्रत्येक स्थानीय प्रतिकृति से परिणाम देता है, और इस परिणाम का उपभोग करने के कई तरीके हैं। आप कुल मूल्य प्राप्त करने के लिए tf.distribute.Strategy.reduce कर सकते हैं। आप परिणाम में निहित मूल्यों की सूची प्राप्त करने के लिए tf.distribute.Strategy.experimental_local_results भी कर सकते हैं, प्रति स्थानीय प्रतिकृति एक।

नवीनतम चेकपॉइंट और परीक्षण को पुनर्स्थापित करें

एक मॉडल जिसे tf.distribute.Strategy साथ tf.distribute.Strategy जाता है, एक रणनीति के साथ या उसके बिना बहाल किया जा सकता है।

077ce02c0
@tf.function
def eval_step(images, labels):
  predictions = new_model(images, training=False)
  eval_accuracy(labels, predictions)
checkpoint = tf.train.Checkpoint(optimizer=new_optimizer, model=new_model)
checkpoint.restore(tf.train.latest_checkpoint(checkpoint_dir))

for images, labels in test_dataset:
  eval_step(images, labels)

print ('Accuracy after restoring the saved model without strategy: {}'.format(
    eval_accuracy.result()*100))
0d09439000

डेटासेट पर पुनरावृति के वैकल्पिक तरीके

पुनरावृत्तियों का उपयोग करना

आप पूरे डाटासेट के माध्यम से नहीं चरणों की दी गई संख्या और अधिक पुनरावृति करना चाहते हैं आप एक इटरेटर का उपयोग कर बना सकते हैं iter कॉल और स्पष्ट रूप से कॉल next पुनरावर्तक पर। आप tf.function के अंदर और बाहर दोनों जगह डेटासेट पर पुनरावृति चुन सकते हैं। यहाँ एक छोटा सा स्निपेट है जो इटर्मीटर का उपयोग करते हुए tf.function के बाहर डेटासेट के पुनरावृत्ति को प्रदर्शित करता है।

for _ in range(EPOCHS):
  total_loss = 0.0
  num_batches = 0
  train_iter = iter(train_dist_dataset)

  for _ in range(10):
    total_loss += distributed_train_step(next(train_iter))
    num_batches += 1
  average_train_loss = total_loss / num_batches

  template = ("Epoch {}, Loss: {}, Accuracy: {}")
  print (template.format(epoch+1, average_train_loss, train_accuracy.result()*100))
  train_accuracy.reset_states()
Epoch 10, Loss: 0.12157603353261948, Accuracy: 95.0
Epoch 10, Loss: 0.1367541253566742, Accuracy: 94.6875
Epoch 10, Loss: 0.14902949333190918, Accuracy: 93.90625
Epoch 10, Loss: 0.12149540334939957, Accuracy: 95.625
Epoch 10, Loss: 0.13160167634487152, Accuracy: 94.6875
Epoch 10, Loss: 0.13297739624977112, Accuracy: 95.3125
Epoch 10, Loss: 0.16038034856319427, Accuracy: 94.53125
Epoch 10, Loss: 0.1035340279340744, Accuracy: 96.40625
Epoch 10, Loss: 0.11846740543842316, Accuracy: 95.625
Epoch 10, Loss: 0.09006750583648682, Accuracy: 96.71875

एक tf.function के अंदर Iterating

आप संपूर्ण इनपुट train_dist_dataset अंदर for x in ... के for x in ... का उपयोग करके पुनरावृत्ति भी कर सकते हैं for x in ... निर्माण या हम ऊपर किए गए पुनरावृत्तियों का निर्माण करके। नीचे दिया गया उदाहरण एक tf.function में प्रशिक्षण के एक युग को लपेटता है और फ़ंक्शन के अंदर train_dist_dataset पर पुनरावृत्ति करता है।

@tf.function
def distributed_train_epoch(dataset):
  total_loss = 0.0
  num_batches = 0
  for x in dataset:
    per_replica_losses = strategy.run(train_step, args=(x,))
    total_loss += strategy.reduce(
      tf.distribute.ReduceOp.SUM, per_replica_losses, axis=None)
    num_batches += 1
  return total_loss / tf.cast(num_batches, dtype=tf.float32)

for epoch in range(EPOCHS):
  train_loss = distributed_train_epoch(train_dist_dataset)

  template = ("Epoch {}, Loss: {}, Accuracy: {}")
  print (template.format(epoch+1, train_loss, train_accuracy.result()*100))

  train_accuracy.reset_states()
Epoch 1, Loss: 0.13680464029312134, Accuracy: 94.90499877929688
Epoch 2, Loss: 0.12503673136234283, Accuracy: 95.33499908447266
Epoch 3, Loss: 0.11472766101360321, Accuracy: 95.71333312988281
Epoch 4, Loss: 0.10419528931379318, Accuracy: 96.13500213623047
Epoch 5, Loss: 0.09566374123096466, Accuracy: 96.44833374023438
Epoch 6, Loss: 0.08704081922769547, Accuracy: 96.82499694824219
Epoch 7, Loss: 0.08157625794410706, Accuracy: 96.96333312988281
Epoch 8, Loss: 0.07562965154647827, Accuracy: 97.11000061035156
Epoch 9, Loss: 0.0676642507314682, Accuracy: 97.47999572753906
Epoch 10, Loss: 0.06430575996637344, Accuracy: 97.58333587646484

प्रतिकृतियों में ट्रैकिंग प्रशिक्षण हानि

हम अलग-अलग प्रतिकृतियों में प्रशिक्षण हानि को ट्रैक करने के लिए tf.metrics.Mean का उपयोग करने की अनुशंसा नहीं करते हैं, क्योंकि नुकसान स्केलिंग गणना की जाती है।

उदाहरण के लिए, यदि आप निम्नलिखित विशेषताओं के साथ एक प्रशिक्षण कार्य चलाते हैं:

  • दो प्रतिकृतियां
  • प्रत्येक प्रतिकृति पर दो नमूने संसाधित किए जाते हैं
  • परिणामी हानि मान: प्रत्येक प्रतिकृति पर [2, 3] और [4, 5]
  • वैश्विक बैच का आकार = 4

हानि स्केलिंग के साथ, आप प्रत्येक प्रतिकृति पर हानि मान जोड़कर प्रति-नमूना मान की गणना करते हैं, और फिर वैश्विक बैच आकार से विभाजित करते हैं। इस स्थिति में: (2 + 3) / 4 = 1.25 और (4 + 5) / 4 = 2.25

यदि आप दो प्रतिकृतियों में नुकसान को ट्रैक करने के लिए tf.metrics.Mean का उपयोग करते हैं, तो परिणाम भिन्न होता है। इस उदाहरण में, आप total 3.50 और 2 की count के साथ समाप्त होते हैं, जिसके परिणामस्वरूप total / count = 1.75 होती है जब result() मीट्रिक पर कहा जाता है। tf.keras.Metrics साथ गणना की गई हानि एक अतिरिक्त कारक द्वारा tf.keras.Metrics जाती है जो सिंक में प्रतिकृतियों की संख्या के बराबर होती है।

गाइड और उदाहरण

कस्टम प्रशिक्षण छोरों के साथ वितरण रणनीति का उपयोग करने के लिए यहां कुछ उदाहरण दिए गए हैं:

  1. वितरित प्रशिक्षण गाइड
  2. DenseNet उदाहरण का उपयोग MirroredStrategy
  3. बर्ट उदाहरण का उपयोग प्रशिक्षित MirroredStrategy और TPUStrategy । यह उदाहरण विशेष रूप से समझने के लिए है कि चेकपॉइंट से कैसे लोड किया जाए और वितरित प्रशिक्षण आदि के दौरान आवधिक चौकियों को उत्पन्न किया जाए।
  4. एनसीएफ उदाहरण का उपयोग प्रशिक्षित MirroredStrategy कि का उपयोग कर सक्रिय किया जा सकता keras_use_ctl झंडा।
  5. NMT उदाहरण का उपयोग प्रशिक्षित MirroredStrategy

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

अगला कदम