তারিখটা মনে রেখো! গুগল I / O মে 18-20 মে এখনই রেজিস্টার করুন
This page was translated by the Cloud Translation API.
Switch to English

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

টেনসরফ্লো.আর.জে দেখুন গুগল কোলাবে চালান গিটহাবের উত্স দেখুন নোটবুক ডাউনলোড করুন

এই টিউটোরিয়ালটি দেখায় যে কীভাবে কাস্টম প্রশিক্ষণ লুপগুলির সাথে tf.distribute.Strategy ব্যবহার করা tf.distribute.Strategy । আমরা ফ্যাশন এমএনআইএসটি ডেটাসেটের জন্য একটি সাধারণ সিএনএন মডেলকে প্রশিক্ষণ দেব। ফ্যাশন এমএনআইএসটি ডেটাসেটে 28 x 28 আকারের 60000 ট্রেনের চিত্র এবং 28 x 28 আকারের 10000 পরীক্ষার চিত্র রয়েছে।

আমরা আমাদের মডেলটিকে প্রশিক্ষণ দিতে কাস্টম প্রশিক্ষণ লুপগুলি ব্যবহার করছি কারণ তারা আমাদের নমনীয়তা এবং প্রশিক্ষণের উপর আরও বেশি নিয়ন্ত্রণ দেয়। তদতিরিক্ত, মডেল এবং প্রশিক্ষণের লুপটি ডিবাগ করা সহজ easier

# Import TensorFlow
import tensorflow as tf

# Helper libraries
import numpy as np
import os

print(tf.__version__)
2.4.1

ফ্যাশন এমএনআইএসটি ডেটাসেট ডাউনলোড করুন

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 [==============================] - 0s 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 [==============================] - 0s 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

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

প্লাটফর্ম-অজোনস্টিক সেভডমোডেল ফর্ম্যাটে গ্রাফ এবং ভেরিয়েবলগুলি রফতানি করুন। আপনার মডেলটি সংরক্ষণ করার পরে, আপনি এটিকে বা সুযোগ ছাড়াই লোড করতে পারেন।

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 টি ব্যাচের আকার রয়েছে input

  • প্রতিটি প্রতিরূপের মডেলটি তার সম্পর্কিত ইনপুট সহ একটি ফরোয়ার্ড পাস করে এবং ক্ষতির গণনা করে। এখন, ক্ষতি সম্পর্কিত ক্ষতিভোগের জন্য নিজ নিজ ইনপুট (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 ব্যবহার করতে পারেন tf.nn.compute_average_loss যা প্রতিটি উদাহরণ হিসাবে ক্ষতি, alচ্ছিক নমুনা ওজন এবং GLOBAL_BATCH_SIZE হিসাবে যুক্তি হিসাবে গ্রহণ করে এবং ক্ষুদ্র ক্ষতির পরিমাণ দেয়।

  • আপনি যদি আপনার মডেলটিতে নিয়মিতকরণ ক্ষতির ব্যবহার করছেন তবে আপনার প্রতিরূপের সংখ্যা অনুসারে লোকসানের মানটি স্কেল করতে হবে। আপনি tf.nn.scale_regularization_loss ফাংশনটি ব্যবহার করে এটি করতে পারেন।

  • tf.reduce_mean ব্যবহার করার tf.reduce_mean হয় না। এটি করার ফলে ক্ষতি প্রতি প্রকৃত প্রতি প্রতি ব্যাচের আকার দ্বারা বিভক্ত হয় যা ধাপে ধাপে পৃথক হতে পারে।

  • এই হ্রাস এবং স্কেলিং স্বয়ংক্রিয়ভাবে model.compile model.fit 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.5113666653633118, Accuracy: 81.77666473388672, Test Loss: 0.44048795104026794, Test Accuracy: 84.75999450683594
Epoch 2, Loss: 0.34178727865219116, Accuracy: 87.7300033569336, Test Loss: 0.33915770053863525, Test Accuracy: 88.06999969482422
Epoch 3, Loss: 0.2983285188674927, Accuracy: 89.19332885742188, Test Loss: 0.3055931031703949, Test Accuracy: 88.91000366210938
Epoch 4, Loss: 0.2684659957885742, Accuracy: 90.25333404541016, Test Loss: 0.29095324873924255, Test Accuracy: 89.55000305175781
Epoch 5, Loss: 0.24288544058799744, Accuracy: 91.15666961669922, Test Loss: 0.2943626642227173, Test Accuracy: 89.63999938964844
Epoch 6, Loss: 0.2228754460811615, Accuracy: 91.88333129882812, Test Loss: 0.2746399939060211, Test Accuracy: 90.02999877929688
Epoch 7, Loss: 0.2049170583486557, Accuracy: 92.5050048828125, Test Loss: 0.26037952303886414, Test Accuracy: 90.80000305175781
Epoch 8, Loss: 0.1883457750082016, Accuracy: 93.11333465576172, Test Loss: 0.2568276524543762, Test Accuracy: 90.9000015258789
Epoch 9, Loss: 0.17290380597114563, Accuracy: 93.61000061035156, Test Loss: 0.2655820846557617, Test Accuracy: 90.55000305175781
Epoch 10, Loss: 0.15979470312595367, Accuracy: 94.12000274658203, Test Loss: 0.2730286419391632, Test Accuracy: 90.52999877929688

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

  • আমরা train_dist_dataset এবং test_dist_dataset for x in ... test_dist_dataset ব্যবহার করে পুনরাবৃত্তি করছি।
  • স্কেলড লস হ'ল distributed_train_step রিটার্ন মান। এই মানটি 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.reduce করতে পারেন। স্থানীয় প্রতিলিপি প্রতি এক, ফলাফলের মধ্যে থাকা মানগুলির তালিকা পেতে আপনি tf.distribute.Strategy.experimental_local_results করতে পারেন।

সর্বশেষতম চেকপয়েন্ট এবং পরীক্ষা পুনরুদ্ধার করুন

tf.distribute.Strategy সহ একটি মডেল 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: 90.55000305175781

কোনও ডেটাসেটের মাধ্যমে পুনরাবৃত্তি করার বিকল্প উপায়

পুনরুক্তি ব্যবহার করে

আপনি যদি কোনও প্রদত্ত সংখ্যক পদক্ষেপের উপরে পুনরাবৃত্তি করতে চান এবং পুরো ডেটাसेटের মাধ্যমে নয় তবে আপনি পুনরাবৃত্তির 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.13083496689796448, Accuracy: 95.0
Epoch 10, Loss: 0.13865676522254944, Accuracy: 94.375
Epoch 10, Loss: 0.12255267798900604, Accuracy: 95.78125
Epoch 10, Loss: 0.16597780585289001, Accuracy: 94.375
Epoch 10, Loss: 0.1374451071023941, Accuracy: 94.6875
Epoch 10, Loss: 0.11878655105829239, Accuracy: 95.3125
Epoch 10, Loss: 0.1515883207321167, Accuracy: 93.75
Epoch 10, Loss: 0.14494936168193817, Accuracy: 95.46875
Epoch 10, Loss: 0.16899390518665314, Accuracy: 94.375
Epoch 10, Loss: 0.12619170546531677, Accuracy: 95.3125

একটি tf.function ভিতরে আইট্রেটিং

আপনি for x in ... কনস্ট্রাক্ট ব্যবহার করে বা আমাদের উপরের মতো পুনরাবৃত্তি তৈরি করে train_dist_dataset ভিতরে পুরো ইনপুট train_dist_dataset মাধ্যমে পুনরাবৃত্তি করতে পারেন। নীচের উদাহরণটি দেখায় যে একটি tf.function এ প্রশিক্ষণের একটি মহাকাশ মোড়ানো এবং ফাংশনের ভিতরে train_dist_dataset উপর 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.1478981077671051, Accuracy: 94.64833068847656
Epoch 2, Loss: 0.13465435802936554, Accuracy: 95.04833221435547
Epoch 3, Loss: 0.12460654228925705, Accuracy: 95.43000030517578
Epoch 4, Loss: 0.11515416204929352, Accuracy: 95.80000305175781
Epoch 5, Loss: 0.10600292682647705, Accuracy: 96.06999969482422
Epoch 6, Loss: 0.10013402998447418, Accuracy: 96.30500030517578
Epoch 7, Loss: 0.09145957976579666, Accuracy: 96.60833740234375
Epoch 8, Loss: 0.08386243134737015, Accuracy: 96.88999938964844
Epoch 9, Loss: 0.07785602658987045, Accuracy: 97.06500244140625
Epoch 10, Loss: 0.0744374692440033, Accuracy: 97.19166564941406

প্রতিরূপ জুড়ে ট্র্যাকিং প্রশিক্ষণ ক্ষতি

লোকসান স্কেলিং গণনা করা হয়েছে বলে বিভিন্ন প্রতিরূপ জুড়ে প্রশিক্ষণের ক্ষতি ট্র্যাক করতে আমরা tf.metrics.Mean ব্যবহার করার পরামর্শ দিই না

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

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

ক্ষতির স্কেলিংয়ের মাধ্যমে, আপনি ক্ষতির মানগুলি যোগ করে এবং তারপরে বৈশ্বিক ব্যাচের আকার দ্বারা বিভাজন করে প্রতিটি প্রতিরূপে ক্ষতির প্রতি-নমুনা মান গণনা করুন। এই ক্ষেত্রে: (2 + 3) / 4 = 1.25 এবং (4 + 5) / 4 = 2.25

যদি আপনি দুটি প্রতিরূপ জুড়ে লোকসান ট্র্যাক করতে tf.metrics.Mean ব্যবহার করেন, ফলাফল ভিন্ন। এই উদাহরণস্বরূপ, আপনি total ৩.৫০ এবং ২ টি count দিয়ে শেষ করেছেন, result() মেট্রিককে ডাকা হলে total / count = 1.75 result() হয়। tf.keras.Metrics দিয়ে গণনা করা হয়েছে tf.keras.Metrics একটি অতিরিক্ত ফ্যাক্টর দ্বারা স্কেল করা হয় যা সিঙ্কে প্রতিরূপের সংখ্যার সমান।

গাইড এবং উদাহরণ

কাস্টম প্রশিক্ষণ লুপগুলির সাথে বিতরণ কৌশল ব্যবহারের জন্য এখানে কয়েকটি উদাহরণ রয়েছে:

  1. বিতরণ প্রশিক্ষণ গাইড
  2. DenseNet উদাহরণ ব্যবহার MirroredStrategy
  3. বার্ট উদাহরণ ব্যবহার প্রশিক্ষিত MirroredStrategy এবং TPUStrategy । এই উদাহরণটি কীভাবে কোনও চেকপয়েন্ট থেকে লোড করা এবং বিতরণ প্রশিক্ষণের সময় পর্যায়ক্রমিক চেকপয়েন্ট তৈরি করা ইত্যাদি বোঝার জন্য বিশেষভাবে সহায়ক is
  4. NCF উদাহরণ ব্যবহার প্রশিক্ষিত MirroredStrategy যে ব্যবহার সক্ষম করা যাবে keras_use_ctl পতাকা।
  5. NMT উদাহরণ ব্যবহার প্রশিক্ষিত MirroredStrategy

বন্টন কৌশল গাইডে আরও উদাহরণ উদাহরণ রয়েছে।

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