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

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

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)

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 ব্যবহার করে একটি মডেল তৈরি করুন। আপনি এটি করতে মডেল সাবক্লাসিং 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) দ্বারা ভাগ করা উচিত।

কেন এই কাজ?

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

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

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

• এই হ্রাস এবং স্কেলিং model.compile এবং model.fit এ স্বয়ংক্রিয়ভাবে সম্পন্ন হয়

• tf.keras.losses ক্লাস ব্যবহার করলে (নীচের উদাহরণের মতো), ক্ষতি হ্রাসকে NONE বা SUM এর একটি হতে স্পষ্টভাবে উল্লেখ করতে হবে। tf.distribute.Strategy এর সাথে ব্যবহার করার সময় AUTO এবং SUM_OVER_BATCH_SIZE অনুমোদিত tf.distribute.Strategy । 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

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

• আমরা 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 করতে পারেন, প্রতি স্থানীয় প্রতিলিপিতে একটি।

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

একটি 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

একটি ডেটাসেটের উপর পুনরাবৃত্তি করার বিকল্প উপায়

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

আপনি যদি একটি নির্দিষ্ট সংখ্যক ধাপে পুনরাবৃত্তি করতে চান এবং পুরো ডেটাসেটের মাধ্যমে নয় তাহলে আপনি 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.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-এর ভিতরে পুরো ইনপুট train_dist_dataset উপর পুনরুক্তি করতে পারেন for x in ... construct ব্যবহার করে বা ইটারেটর তৈরি করে যেমন আমরা উপরে করেছি। নীচের উদাহরণটি একটি 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. DenseNet উদাহরণ MirroredStrategy ব্যবহার করে।
3. TPUStrategy উদাহরণ MirroredStrategy এবং TPUStrategy ব্যবহার করে প্রশিক্ষিত। এই উদাহরণটি একটি চেকপয়েন্ট থেকে কীভাবে লোড করা যায় এবং বিতরণ করা প্রশিক্ষণ ইত্যাদির সময় পর্যায়ক্রমিক চেকপয়েন্ট তৈরি করা যায় তা বোঝার জন্য বিশেষভাবে সহায়ক।
4. NCF উদাহরণ MirroredStrategy ব্যবহার করে প্রশিক্ষিত যা keras_use_ctl পতাকা ব্যবহার করে সক্ষম করা যেতে পারে।
5. NMT উদাহরণ MirroredStrategy ব্যবহার করে প্রশিক্ষিত।

বিতরণ কৌশল নির্দেশিকাতে তালিকাভুক্ত আরও উদাহরণ।

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

• আপনার মডেলগুলিতে নতুন tf.distribute.Strategy API ব্যবহার করে দেখুন।
• আপনার টেনসরফ্লো মডেলের পারফরম্যান্স অপ্টিমাইজ করতে আপনি ব্যবহার করতে পারেন এমন অন্যান্য কৌশল এবং সরঞ্জামগুলি সম্পর্কে আরও জানতে গাইডের পারফরম্যান্স বিভাগে যান৷