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

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

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

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

# Import TensorFlow
import tensorflow as tf

# Helper libraries
import numpy as np
import os

print(tf.__version__)
2.5.0

फैशन एमएनआईएसटी डेटासेट डाउनलोड करें

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)

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

कैसे 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()
WARNING:tensorflow:Collective ops is not configured at program startup. Some performance features may not be enabled.
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

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

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

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 GPU/CPU वाली एकल मशीन पर, हानि को इनपुट के बैच में उदाहरणों की संख्या से विभाजित किया जाता है।

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

  • उदाहरण के लिए, मान लें कि आपके पास 4 GPU है और 64 का बैच आकार है। इनपुट का एक बैच प्रतिकृतियों (4 GPU) में वितरित किया जाता है, प्रत्येक प्रतिकृति को आकार 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 जो उदाहरण प्रति हानि, वैकल्पिक नमूना वजन, और तर्क और रिटर्न स्केल की हानि के रूप में GLOBAL_BATCH_SIZE लेता है।

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

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

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

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

  • तो labels बहु-आयामी है, तो औसत per_example_loss प्रत्येक नमूने में तत्वों की संख्या के पार। उदाहरण के लिए, के आकार अगर predictions है (batch_size, H, W, n_classes) और labels है (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')
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',).

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

# 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()
Epoch 1, Loss: 0.5044084787368774, Accuracy: 81.87333679199219, Test Loss: 0.3816865086555481, Test Accuracy: 86.5999984741211
Epoch 2, Loss: 0.3375805616378784, Accuracy: 87.8566665649414, Test Loss: 0.3369813859462738, Test Accuracy: 87.76000213623047
Epoch 3, Loss: 0.2896445095539093, Accuracy: 89.50499725341797, Test Loss: 0.299490362405777, Test Accuracy: 89.22000122070312
Epoch 4, Loss: 0.259074866771698, Accuracy: 90.58833312988281, Test Loss: 0.2881558835506439, Test Accuracy: 89.33000183105469
Epoch 5, Loss: 0.2341146171092987, Accuracy: 91.38999938964844, Test Loss: 0.2916182577610016, Test Accuracy: 89.61000061035156
Epoch 6, Loss: 0.21513047814369202, Accuracy: 92.02333068847656, Test Loss: 0.2755740284919739, Test Accuracy: 89.85000610351562
Epoch 7, Loss: 0.1952667236328125, Accuracy: 92.88333129882812, Test Loss: 0.27464523911476135, Test Accuracy: 90.36000061035156
Epoch 8, Loss: 0.17831537127494812, Accuracy: 93.3566665649414, Test Loss: 0.26432710886001587, Test Accuracy: 90.19000244140625
Epoch 9, Loss: 0.16429665684700012, Accuracy: 93.85333251953125, Test Loss: 0.2659859359264374, Test Accuracy: 91.0999984741211
Epoch 10, Loss: 0.1503313183784485, Accuracy: 94.42166900634766, Test Loss: 0.2602477967739105, Test Accuracy: 91.06999969482422

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

  • हम से अधिक पुनरावृत्ति कर रहे हैं train_dist_dataset और test_dist_dataset एक का उपयोग कर for x in ... निर्माण।
  • बढ़ाया नुकसान की वापसी मान है distributed_train_step । यह मान का उपयोग कर प्रतिकृतियां भर में एकत्रित किया जाता है 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 सूची प्राप्त करने के मूल्यों परिणाम, स्थानीय प्रतिकृति प्रति एक में निहित।

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

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

eval_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(
      name='eval_accuracy')

new_model = create_model()
new_optimizer = tf.keras.optimizers.Adam()

test_dataset = tf.data.Dataset.from_tensor_slices((test_images, test_labels)).batch(GLOBAL_BATCH_SIZE)
@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))
Accuracy after restoring the saved model without strategy: 91.0999984741211

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

इटरेटर्स का उपयोग करना

आप पूरे डाटासेट के माध्यम से नहीं चरणों की दी गई संख्या और अधिक पुनरावृति करना चाहते हैं आप एक इटरेटर का उपयोग कर बना सकते हैं 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.14126229286193848, Accuracy: 95.0
Epoch 10, Loss: 0.1343936026096344, Accuracy: 95.0
Epoch 10, Loss: 0.12443388998508453, Accuracy: 94.84375
Epoch 10, Loss: 0.1607474684715271, Accuracy: 94.21875
Epoch 10, Loss: 0.10524413734674454, Accuracy: 96.71875
Epoch 10, Loss: 0.11492376029491425, Accuracy: 96.71875
Epoch 10, Loss: 0.16041627526283264, Accuracy: 94.21875
Epoch 10, Loss: 0.13022005558013916, Accuracy: 94.6875
Epoch 10, Loss: 0.17113295197486877, Accuracy: 93.28125
Epoch 10, Loss: 0.12315043061971664, Accuracy: 95.625

एक tf.function के अंदर पुनरावृति

तुम भी पुनरावृति पूरे इनपुट से अधिक कर सकते हैं train_dist_dataset एक tf.function का उपयोग कर के अंदर for x in ... निर्माण या द्वारा iterators बनाने की तरह हम ऊपर था। नीचे दिए गए उदाहरण एक 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.13766956329345703, Accuracy: 94.89666748046875
Epoch 2, Loss: 0.12510614097118378, Accuracy: 95.35166931152344
Epoch 3, Loss: 0.11464647948741913, Accuracy: 95.70333099365234
Epoch 4, Loss: 0.10295023769140244, Accuracy: 96.12000274658203
Epoch 5, Loss: 0.09352775663137436, Accuracy: 96.49666595458984
Epoch 6, Loss: 0.08494547754526138, Accuracy: 96.87166595458984
Epoch 7, Loss: 0.07917638123035431, Accuracy: 97.09166717529297
Epoch 8, Loss: 0.07128290832042694, Accuracy: 97.37833404541016
Epoch 9, Loss: 0.06662175804376602, Accuracy: 97.47999572753906
Epoch 10, Loss: 0.06016768515110016, Accuracy: 97.82833099365234

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

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

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

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

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

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

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

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

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

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

अगले कदम

  • नई आजमाएँ tf.distribute.Strategy अपने मॉडल पर एपीआई।
  • पर जाएं प्रदर्शन अनुभाग गाइड में अन्य रणनीतियों और के बारे में अधिक जानने के लिए उपकरण है कि आप अपने TensorFlow मॉडल के प्रदर्शन का अनुकूलन करने के लिए उपयोग कर सकते हैं।