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.8.0-rc1

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

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()

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)

2022-01-26 05:45:53.991501: W tensorflow/core/grappler/optimizers/data/auto_shard.cc:776] AUTO sharding policy will apply DATA sharding policy as it failed to apply FILE sharding policy because of the following reason: Found an unshardable source dataset: name: "TensorSliceDataset/_2"
op: "TensorSliceDataset"
input: "Placeholder/_0"
input: "Placeholder/_1"
attr {
  key: "Toutput_types"
  value {
    list {
      type: DT_FLOAT
      type: DT_UINT8
    }
  }
}
attr {
  key: "_cardinality"
  value {
    i: 60000
  }
}
attr {
  key: "is_files"
  value {
    b: false
  }
}
attr {
  key: "metadata"
  value {
    s: "\n\024TensorSliceDataset:0"
  }
}
attr {
  key: "output_shapes"
  value {
    list {
      shape {
        dim {
          size: 28
        }
        dim {
          size: 28
        }
        dim {
          size: 1
        }
      }
      shape {
      }
    }
  }
}
experimental_type {
  type_id: TFT_PRODUCT
  args {
    type_id: TFT_DATASET
    args {
      type_id: TFT_PRODUCT
      args {
        type_id: TFT_TENSOR
        args {
          type_id: TFT_FLOAT
        }
      }
      args {
        type_id: TFT_TENSOR
        args {
          type_id: TFT_UINT8
        }
      }
    }
  }
  args {
    type_id: TFT_DATASET
    args {
      type_id: TFT_PRODUCT
      args {
        type_id: TFT_TENSOR
        args {
          type_id: TFT_FLOAT
        }
      }
      args {
        type_id: TFT_TENSOR
        args {
          type_id: TFT_UINT8
        }
      }
    }
  }
}

2022-01-26 05:45:54.034762: W tensorflow/core/grappler/optimizers/data/auto_shard.cc:776] AUTO sharding policy will apply DATA sharding policy as it failed to apply FILE sharding policy because of the following reason: Found an unshardable source dataset: name: "TensorSliceDataset/_2"
op: "TensorSliceDataset"
input: "Placeholder/_0"
input: "Placeholder/_1"
attr {
  key: "Toutput_types"
  value {
    list {
      type: DT_FLOAT
      type: DT_UINT8
    }
  }
}
attr {
  key: "_cardinality"
  value {
    i: 10000
  }
}
attr {
  key: "is_files"
  value {
    b: false
  }
}
attr {
  key: "metadata"
  value {
    s: "\n\024TensorSliceDataset:3"
  }
}
attr {
  key: "output_shapes"
  value {
    list {
      shape {
        dim {
          size: 28
        }
        dim {
          size: 28
        }
        dim {
          size: 1
        }
      }
      shape {
      }
    }
  }
}
experimental_type {
  type_id: TFT_PRODUCT
  args {
    type_id: TFT_DATASET
    args {
      type_id: TFT_PRODUCT
      args {
        type_id: TFT_TENSOR
        args {
          type_id: TFT_FLOAT
        }
      }
      args {
        type_id: TFT_TENSOR
        args {
          type_id: TFT_UINT8
        }
      }
    }
  }
  args {
    type_id: TFT_DATASET
    args {
      type_id: TFT_PRODUCT
      args {
        type_id: TFT_TENSOR
        args {
          type_id: TFT_FLOAT
        }
      }
      args {
        type_id: TFT_TENSOR
        args {
          type_id: TFT_UINT8
        }
      }
    }
  }
}

मॉडल बनाएं

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 का उपयोग कर सकते हैं 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 या SUM में से एक होने के लिए निर्दिष्ट करने की आवश्यकता है। tf. tf.distribute.Strategy के साथ उपयोग किए जाने पर AUTO और SUM_OVER_BATCH_SIZE की अनुमति नहीं है। AUTO की अनुमति नहीं है क्योंकि उपयोगकर्ता को स्पष्ट रूप से सोचना चाहिए कि वे किस कमी को सुनिश्चित करना चाहते हैं कि यह वितरित मामले में सही है। 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.5106383562088013, Accuracy: 81.77999877929688, Test Loss: 0.39399346709251404, Test Accuracy: 85.79000091552734
Epoch 2, Loss: 0.3362727463245392, Accuracy: 87.91333770751953, Test Loss: 0.35871225595474243, Test Accuracy: 86.7699966430664
Epoch 3, Loss: 0.2928692400455475, Accuracy: 89.2683334350586, Test Loss: 0.2999486029148102, Test Accuracy: 89.04000091552734
Epoch 4, Loss: 0.2605818510055542, Accuracy: 90.41999816894531, Test Loss: 0.28474125266075134, Test Accuracy: 89.47000122070312
Epoch 5, Loss: 0.23641237616539001, Accuracy: 91.32166290283203, Test Loss: 0.26421546936035156, Test Accuracy: 90.41000366210938
Epoch 6, Loss: 0.2192477434873581, Accuracy: 91.90499877929688, Test Loss: 0.2650589942932129, Test Accuracy: 90.4800033569336
Epoch 7, Loss: 0.20016911625862122, Accuracy: 92.66999816894531, Test Loss: 0.25025954842567444, Test Accuracy: 90.9000015258789
Epoch 8, Loss: 0.18381091952323914, Accuracy: 93.26499938964844, Test Loss: 0.2585820257663727, Test Accuracy: 90.95999908447266
Epoch 9, Loss: 0.1699329912662506, Accuracy: 93.67500305175781, Test Loss: 0.26234227418899536, Test Accuracy: 91.0199966430664
Epoch 10, Loss: 0.15756534039974213, Accuracy: 94.16333770751953, Test Loss: 0.25516414642333984, Test Accuracy: 90.93000030517578

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

• हम for x in ... a का उपयोग करके train_dist_dataset और test_dist_dataset पर पुनरावृति कर रहे हैं।
• स्केल्ड लॉस 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 भी कर सकते हैं, एक प्रति स्थानीय प्रतिकृति।

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

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.0199966430664

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

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

यदि आप दिए गए चरणों की next पर पुनरावृति करना चाहते हैं, न कि संपूर्ण डेटासेट के माध्यम से, तो आप पुनरावर्तक पर iter कॉल और स्पष्टीकरण कॉल का उपयोग करके एक पुनरावर्तक बना सकते हैं। आप 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.17486707866191864, Accuracy: 93.4375
Epoch 10, Loss: 0.12386945635080338, Accuracy: 95.3125
Epoch 10, Loss: 0.16411852836608887, Accuracy: 93.90625
Epoch 10, Loss: 0.10728752613067627, Accuracy: 96.40625
Epoch 10, Loss: 0.11865834891796112, Accuracy: 95.625
Epoch 10, Loss: 0.12875251471996307, Accuracy: 95.15625
Epoch 10, Loss: 0.1189488023519516, Accuracy: 95.625
Epoch 10, Loss: 0.1456708014011383, Accuracy: 95.15625
Epoch 10, Loss: 0.12446556240320206, Accuracy: 95.3125
Epoch 10, Loss: 0.1380888819694519, Accuracy: 95.46875

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

आप tf.function के अंदर for x in ... निर्माण का उपयोग करके या ऊपर दिए गए इटरेटर्स बनाकर संपूर्ण इनपुट train_dist_dataset पर पुनरावृति भी कर सकते हैं। नीचे दिया गया उदाहरण एक 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()

/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/data/ops/dataset_ops.py:449: UserWarning: To make it possible to preserve tf.data options across serialization boundaries, their implementation has moved to be part of the TensorFlow graph. As a consequence, the options value is in general no longer known at graph construction time. Invoking this method in graph mode retains the legacy behavior of the original implementation, but note that the returned value might not reflect the actual value of the options.
  warnings.warn("To make it possible to preserve tf.data options across "
Epoch 1, Loss: 0.14398494362831116, Accuracy: 94.63999938964844
Epoch 2, Loss: 0.13246288895606995, Accuracy: 94.97333526611328
Epoch 3, Loss: 0.11922841519117355, Accuracy: 95.63833618164062
Epoch 4, Loss: 0.11084160208702087, Accuracy: 95.99333190917969
Epoch 5, Loss: 0.10420522093772888, Accuracy: 96.0816650390625
Epoch 6, Loss: 0.09215126931667328, Accuracy: 96.63500213623047
Epoch 7, Loss: 0.0878651961684227, Accuracy: 96.67666625976562
Epoch 8, Loss: 0.07854588329792023, Accuracy: 97.09333038330078
Epoch 9, Loss: 0.07217177003622055, Accuracy: 97.34833526611328
Epoch 10, Loss: 0.06753655523061752, Accuracy: 97.48999786376953

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

हम 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 के साथ समाप्त होते हैं, जिसके परिणामस्वरूप मीट्रिक पर result() को कॉल करने पर total / count = 1.75 होती है। tf.keras.Metrics के साथ गणना की गई हानि को एक अतिरिक्त कारक द्वारा बढ़ाया जाता है जो सिंक में प्रतिकृतियों की संख्या के बराबर होता है।

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

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

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

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

अगले कदम

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