সাহায্য Kaggle উপর TensorFlow সঙ্গে গ্রেট বেরিয়ার রিফ রক্ষা চ্যালেঞ্জ যোগদান

Tf.distribute.Strategy সহ কাস্টম প্রশিক্ষণ

TensorFlow.org এ দেখুন Google Colab-এ চালান GitHub-এ উৎস দেখুন নোটবুক ডাউনলোড করুন

এই টিউটোরিয়ালটি প্রমান কীভাবে ব্যবহার করবেন তা tf.distribute.Strategy কাস্টম প্রশিক্ষণ লুপ সঙ্গে। আমরা ফ্যাশন MNIST ডেটাসেটে একটি সাধারণ CNN মডেলকে প্রশিক্ষণ দেব। ফ্যাশন MNIST ডেটাসেটে 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

ফ্যাশন 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)

ভেরিয়েবল এবং গ্রাফ বিতরণ করার জন্য একটি কৌশল তৈরি করুন

কীভাবে 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

ইনপুট পাইপলাইন সেটআপ করুন

গ্রাফ এবং ভেরিয়েবল প্ল্যাটফর্ম-অজ্ঞেয়বাদী 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 । আপনি এটি করতে মডেল সাবক্লাসিং API ব্যবহার করতে পারেন।

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 GPUs) জুড়ে বিতরণ করা হয়, প্রতিটি প্রতিলিপি 16 আকারের একটি ইনপুট পায়।

  • প্রতিটি প্রতিরূপের মডেল তার নিজ নিজ ইনপুট সহ একটি ফরোয়ার্ড পাস করে এবং ক্ষতি গণনা করে। এখন, ক্ষতিকে তার নিজ নিজ ইনপুটের উদাহরণের সংখ্যা দ্বারা ভাগ করার পরিবর্তে (BATCH_SIZE_PER_REPLICA = 16), ক্ষতিটিকে GLOBAL_BATCH_SIZE (64) দ্বারা ভাগ করা উচিত।

কেন এই কাজ?

  • এই কাজ করতে হবে কারণ পর গ্রেডিয়েন্ট প্রতিটি প্রতিরূপ হিসেব করা হয়েছে, তবে তারা তাদেরকে summing দ্বারা প্রতিলিপি জুড়ে সিঙ্ক করা হয় প্রয়োজন।

টেনসরফ্লোতে এটি কীভাবে করবেন?

  • আপনি এই টিউটোরিয়াল হিসেবে একটি কাস্টম প্রশিক্ষণ লুপ, লেখা করছেন, তাহলে আপনি উদাহরণস্বরূপ প্রতি লোকসান যোগফল এবং 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

উপরের উদাহরণে উল্লেখ্য বিষয়গুলি:

  • আমরা উপর iterating হয় train_dist_dataset এবং test_dist_dataset একটি ব্যবহার for x in ... কনস্ট্রাক্ট।
  • স্কেল করা ক্ষতির ফেরত মান হয় distributed_train_step । এই মান ব্যবহার প্রতিলিপি জুড়ে একীকৃত tf.distribute.Strategy.reduce ফেরত মান summing দ্বারা ব্যাচ জুড়ে কল এবং তারপর 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 প্রশিক্ষণ এক যুগান্তকারী মোড়কে এবং উপর iterating প্রমান 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 ক্ষতি স্কেলিং গণনার যে বাহিত হয় কারণ বিভিন্ন প্রতিলিপি জুড়ে প্রশিক্ষণ ক্ষতি ট্র্যাক করতে।

উদাহরণস্বরূপ, আপনি যদি নিম্নলিখিত বৈশিষ্ট্যগুলির সাথে একটি প্রশিক্ষণের কাজ চালান:

  • দুটি প্রতিলিপি
  • প্রতিটি প্রতিলিপিতে দুটি নমুনা প্রক্রিয়া করা হয়
  • ফলাফল ক্ষতির মান: [2, 3] এবং [4, 5] প্রতিটি প্রতিলিপিতে
  • গ্লোবাল ব্যাচের আকার = 4

লস স্কেলিং এর মাধ্যমে, আপনি ক্ষতির মান যোগ করে এবং তারপর গ্লোবাল ব্যাচের আকার দ্বারা ভাগ করে প্রতিটি প্রতিলিপিতে ক্ষতির প্রতি-নমুনা মান গণনা করেন। এই ক্ষেত্রে: (2 + 3) / 4 = 1.25 1,25 এবং (4 + 5) / 4 = 2.25 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. NCF উদাহরণ ব্যবহার প্রশিক্ষিত MirroredStrategy যে ব্যবহার সক্ষম করা যাবে keras_use_ctl পতাকা।
  5. NMT উদাহরণ ব্যবহার প্রশিক্ষিত MirroredStrategy

আরো তালিকাভুক্ত উদাহরণ বিতরণ কৌশল গাইড

পরবর্তী পদক্ষেপ

  • নতুন করে দেখুন tf.distribute.Strategy আপনার মডেলের উপর API- টি।
  • পরিদর্শন পারফরমেন্স অধ্যায় গাইডে অন্যান্য কৌশল ও সম্পর্কে আরো জানতে টুলস আপনি আপনার TensorFlow মডেলের কর্মক্ষমতা নিখুত ব্যবহার করতে পারেন।