ডিবাগ TF2 মাইগ্রেটেড ট্রেনিং পাইপলাইন

TensorFlow.org এ দেখুন

Google Colab-এ চালান

GitHub-এ উৎস দেখুন

নোটবুক ডাউনলোড করুন

এই নোটবুকটি দেখায় কিভাবে TF2 এ স্থানান্তরিত করার সময় প্রশিক্ষণ পাইপলাইন ডিবাগ করতে হয়। এটি নিম্নলিখিত উপাদান নিয়ে গঠিত:

1. প্রশিক্ষণ পাইপলাইন ডিবাগ করার জন্য প্রস্তাবিত পদক্ষেপ এবং কোড নমুনা
2. ডিবাগিংয়ের জন্য সরঞ্জাম
3. অন্যান্য সম্পর্কিত সম্পদ

একটি অনুমান হল আপনার কাছে তুলনা করার জন্য TF1.x কোড এবং প্রশিক্ষিত মডেল রয়েছে এবং আপনি একটি TF2 মডেল তৈরি করতে চান যা একই রকম বৈধতা নির্ভুলতা অর্জন করে।

এই নোটবুকটি প্রশিক্ষণ/অনুমানের গতি বা মেমরি ব্যবহারের জন্য ডিবাগিং কর্মক্ষমতা সমস্যা কভার করে না ।

ডিবাগিং ওয়ার্কফ্লো

নীচে আপনার TF2 প্রশিক্ষণ পাইপলাইন ডিবাগ করার জন্য একটি সাধারণ কর্মপ্রবাহ। মনে রাখবেন যে আপনাকে এই পদক্ষেপগুলি অনুসরণ করতে হবে না। আপনি একটি বাইনারি অনুসন্ধান পদ্ধতিও ব্যবহার করতে পারেন যেখানে আপনি একটি মধ্যবর্তী ধাপে মডেলটি পরীক্ষা করেন এবং ডিবাগিং সুযোগকে সংকুচিত করেন।

1. কম্পাইল এবং রানটাইম ত্রুটি ঠিক করুন

2. একক ফরোয়ার্ড পাস বৈধতা (একটি পৃথক গাইডে )

   ক একক CPU ডিভাইসে

   • যাচাই করুন ভেরিয়েবল শুধুমাত্র একবার তৈরি করা হয়
   • পরিবর্তনশীল গণনা, নাম, এবং আকারের মিল পরীক্ষা করুন
   • সমস্ত ভেরিয়েবল রিসেট করুন, সমস্ত এলোমেলোতা অক্ষম করে সাংখ্যিক সমতা পরীক্ষা করুন
   • এলোমেলো সংখ্যা প্রজন্ম সারিবদ্ধ করুন, অনুমানে সংখ্যাসূচক সমতা পরীক্ষা করুন
   • (ঐচ্ছিক) চেকপয়েন্টগুলি সঠিকভাবে লোড করা হয়েছে এবং TF1.x/TF2 মডেলগুলি identitcal আউটপুট তৈরি করে

   খ. একক GPU/TPU ডিভাইসে

   গ. মাল্টি-ডিভাইস কৌশল সহ

3. কয়েকটি ধাপের জন্য মডেল প্রশিক্ষণ সংখ্যাসূচক সমতা যাচাইকরণ (নিচে উপলব্ধ কোড নমুনা)

   ক একক CPU ডিভাইসে ছোট এবং স্থির ডেটা ব্যবহার করে একক প্রশিক্ষণ ধাপের বৈধতা। বিশেষত, নিম্নলিখিত উপাদানগুলির জন্য সংখ্যাসূচক সমতা পরীক্ষা করুন

   • লোকসান গণনা
   • মেট্রিক্স
   • শেখার হার
   • গ্রেডিয়েন্ট গণনা এবং আপডেট

   খ. একক CPU ডিভাইসে স্থির ডেটা সহ মোমেন্টামের মতো অপ্টিমাইজার আচরণ যাচাই করতে 3 বা তার বেশি ধাপ প্রশিক্ষণের পরে পরিসংখ্যান পরীক্ষা করুন

   গ. একক GPU/TPU ডিভাইসে

   d মাল্টি-ডিভাইস কৌশল সহ (নীচে মাল্টিপ্রসেসরানারের ভূমিকা দেখুন)

4. বাস্তব ডেটাসেটে এন্ড-টু-এন্ড কভারজেন্স টেস্টিং

   ক টেনসরবোর্ডের সাথে প্রশিক্ষণের আচরণ পরীক্ষা করুন

   • সাধারণ অপ্টিমাইজার ব্যবহার করুন যেমন SGD এবং সহজ বিতরণ কৌশল যেমন tf.distribute.OneDeviceStrategy প্রথমে
   • প্রশিক্ষণ মেট্রিক্স
   • মূল্যায়ন মেট্রিক্স
   • সহজাত এলোমেলোতার জন্য যুক্তিসঙ্গত সহনশীলতা কি তা বের করুন

   খ. উন্নত অপ্টিমাইজার/শিক্ষার হার নির্ধারণকারী/বন্টন কৌশলগুলির সাথে সমতা পরীক্ষা করুন

   গ. মিশ্র নির্ভুলতা ব্যবহার করার সময় সমতা পরীক্ষা করুন

5. অতিরিক্ত পণ্য বেঞ্চমার্ক

সেটআপ

pip uninstall -y -q tensorflow

# Install tf-nightly as the DeterministicRandomTestTool is only available in
# Tensorflow 2.8
pip install -q tf-nightly

একক ফরোয়ার্ড পাস বৈধতা

চেকপয়েন্ট লোডিং সহ একক ফরোয়ার্ড পাসের বৈধতা একটি ভিন্ন কোলাবে কভার করা হয়েছে।

import sys
import unittest
import numpy as np

import tensorflow as tf
import tensorflow.compat.v1 as v1

কয়েকটি ধাপের জন্য মডেল প্রশিক্ষণ সংখ্যাসূচক সমতা যাচাই

মডেল কনফিগারেশন সেট আপ করুন এবং একটি জাল ডেটাসেট প্রস্তুত করুন।

params = {
    'input_size': 3,
    'num_classes': 3,
    'layer_1_size': 2,
    'layer_2_size': 2,
    'num_train_steps': 100,
    'init_lr': 1e-3,
    'end_lr': 0.0,
    'decay_steps': 1000,
    'lr_power': 1.0,
}

# make a small fixed dataset
fake_x = np.ones((2, params['input_size']), dtype=np.float32)
fake_y = np.zeros((2, params['num_classes']), dtype=np.int32)
fake_y[0][0] = 1
fake_y[1][1] = 1

step_num = 3

TF1.x মডেলটি সংজ্ঞায়িত করুন।

# Assume there is an existing TF1.x model using estimator API
# Wrap the model_fn to log necessary tensors for result comparison
class SimpleModelWrapper():
  def __init__(self):
    self.logged_ops = {}
    self.logs = {
        'step': [],
        'lr': [],
        'loss': [],
        'grads_and_vars': [],
        'layer_out': []}

  def model_fn(self, features, labels, mode, params):
      out_1 = tf.compat.v1.layers.dense(features, units=params['layer_1_size'])
      out_2 = tf.compat.v1.layers.dense(out_1, units=params['layer_2_size'])
      logits = tf.compat.v1.layers.dense(out_2, units=params['num_classes'])
      loss = tf.compat.v1.losses.softmax_cross_entropy(labels, logits)

      # skip EstimatorSpec details for prediction and evaluation 
      if mode == tf.estimator.ModeKeys.PREDICT:
          pass
      if mode == tf.estimator.ModeKeys.EVAL:
          pass
      assert mode == tf.estimator.ModeKeys.TRAIN

      global_step = tf.compat.v1.train.get_or_create_global_step()
      lr = tf.compat.v1.train.polynomial_decay(
        learning_rate=params['init_lr'],
        global_step=global_step,
        decay_steps=params['decay_steps'],
        end_learning_rate=params['end_lr'],
        power=params['lr_power'])

      optmizer = tf.compat.v1.train.GradientDescentOptimizer(lr)
      grads_and_vars = optmizer.compute_gradients(
          loss=loss,
          var_list=graph.get_collection(
              tf.compat.v1.GraphKeys.TRAINABLE_VARIABLES))
      train_op = optmizer.apply_gradients(
          grads_and_vars,
          global_step=global_step)

      # log tensors
      self.logged_ops['step'] = global_step
      self.logged_ops['lr'] = lr
      self.logged_ops['loss'] = loss
      self.logged_ops['grads_and_vars'] = grads_and_vars
      self.logged_ops['layer_out'] = {
          'layer_1': out_1,
          'layer_2': out_2,
          'logits': logits}

      return tf.estimator.EstimatorSpec(mode, loss=loss, train_op=train_op)

  def update_logs(self, logs):
    for key in logs.keys():
      model_tf1.logs[key].append(logs[key])

নিম্নলিখিত v1.keras.utils.DeterministicRandomTestTool ক্লাস একটি প্রসঙ্গ ম্যানেজার scope() প্রদান করে যা স্টেটফুল র্যান্ডম অপারেশনগুলিকে TF1 গ্রাফ/সেশন এবং আগ্রহী সম্পাদন উভয় জুড়ে একই বীজ ব্যবহার করতে পারে,

টুল দুটি পরীক্ষার মোড প্রদান করে:

1. constant যা প্রতিটি একক অপারেশনের জন্য একই বীজ ব্যবহার করে তা যতবারই বলা হোক না কেন এবং,
2. num_random_ops যা অপারেশন বীজ হিসাবে পূর্বে-পর্যবেক্ষিত স্টেটফুল র্যান্ডম অপারেশনের সংখ্যা ব্যবহার করে।

এটি ভেরিয়েবল তৈরি এবং আরম্ভ করার জন্য ব্যবহৃত স্টেটফুল র্যান্ডম অপারেশন এবং গণনায় ব্যবহৃত স্টেটফুল র্যান্ডম অপারেশন উভয় ক্ষেত্রেই প্রযোজ্য (যেমন ড্রপআউট স্তরগুলির জন্য)।

random_tool = v1.keras.utils.DeterministicRandomTestTool(mode='num_random_ops')

WARNING:tensorflow:From /tmp/ipykernel_26769/2689227634.py:1: The name tf.keras.utils.DeterministicRandomTestTool is deprecated. Please use tf.compat.v1.keras.utils.DeterministicRandomTestTool instead.

গ্রাফ মোডে TF1.x মডেলটি চালান। সাংখ্যিক সমতা তুলনার জন্য প্রথম 3টি প্রশিক্ষণের ধাপের পরিসংখ্যান সংগ্রহ করুন।

with random_tool.scope():
  graph = tf.Graph()
  with graph.as_default(), tf.compat.v1.Session(graph=graph) as sess:
    model_tf1 = SimpleModelWrapper()
    # build the model
    inputs = tf.compat.v1.placeholder(tf.float32, shape=(None, params['input_size']))
    labels = tf.compat.v1.placeholder(tf.float32, shape=(None, params['num_classes']))
    spec = model_tf1.model_fn(inputs, labels, tf.estimator.ModeKeys.TRAIN, params)
    train_op = spec.train_op

    sess.run(tf.compat.v1.global_variables_initializer())
    for step in range(step_num):
      # log everything and update the model for one step
      logs, _ = sess.run(
          [model_tf1.logged_ops, train_op],
          feed_dict={inputs: fake_x, labels: fake_y})
      model_tf1.update_logs(logs)

/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:14: UserWarning: `tf.layers.dense` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dense` instead.
  
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/keras/legacy_tf_layers/core.py:261: UserWarning: `layer.apply` is deprecated and will be removed in a future version. Please use `layer.__call__` method instead.
  return layer.apply(inputs)
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:15: UserWarning: `tf.layers.dense` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dense` instead.
  from ipykernel import kernelapp as app
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/ipykernel_launcher.py:16: UserWarning: `tf.layers.dense` is deprecated and will be removed in a future version. Please use `tf.keras.layers.Dense` instead.
  app.launch_new_instance()

TF2 মডেল সংজ্ঞায়িত করুন।

class SimpleModel(tf.keras.Model):
  def __init__(self, params, *args, **kwargs):
    super(SimpleModel, self).__init__(*args, **kwargs)
    # define the model
    self.dense_1 = tf.keras.layers.Dense(params['layer_1_size'])
    self.dense_2 = tf.keras.layers.Dense(params['layer_2_size'])
    self.out = tf.keras.layers.Dense(params['num_classes'])
    learning_rate_fn = tf.keras.optimizers.schedules.PolynomialDecay(
      initial_learning_rate=params['init_lr'],
      decay_steps=params['decay_steps'],
      end_learning_rate=params['end_lr'],
      power=params['lr_power'])  
    self.optimizer = tf.keras.optimizers.SGD(learning_rate_fn)
    self.compiled_loss = tf.keras.losses.CategoricalCrossentropy(from_logits=True)
    self.logs = {
        'lr': [],
        'loss': [],
        'grads': [],
        'weights': [],
        'layer_out': []}

  def call(self, inputs):
    out_1 = self.dense_1(inputs)
    out_2 = self.dense_2(out_1)
    logits = self.out(out_2)
    # log output features for every layer for comparison
    layer_wise_out = {
        'layer_1': out_1,
        'layer_2': out_2,
        'logits': logits}
    self.logs['layer_out'].append(layer_wise_out)
    return logits

  def train_step(self, data):
    x, y = data
    with tf.GradientTape() as tape:
      logits = self(x)
      loss = self.compiled_loss(y, logits)
    grads = tape.gradient(loss, self.trainable_weights)
    # log training statistics
    step = self.optimizer.iterations.numpy()
    self.logs['lr'].append(self.optimizer.learning_rate(step).numpy())
    self.logs['loss'].append(loss.numpy())
    self.logs['grads'].append(grads)
    self.logs['weights'].append(self.trainable_weights)
    # update model
    self.optimizer.apply_gradients(zip(grads, self.trainable_weights))
    return

আগ্রহী মোডে TF2 মডেল চালান। সাংখ্যিক সমতা তুলনার জন্য প্রথম 3টি প্রশিক্ষণের ধাপের পরিসংখ্যান সংগ্রহ করুন।

random_tool = v1.keras.utils.DeterministicRandomTestTool(mode='num_random_ops')
with random_tool.scope():
  model_tf2 = SimpleModel(params)
  for step in range(step_num):
    model_tf2.train_step([fake_x, fake_y])

প্রথম কয়েকটি প্রশিক্ষণের ধাপের জন্য সংখ্যাসূচক সমতা তুলনা করুন।

আপনি সংখ্যাসূচক সমতার জন্য অতিরিক্ত পরামর্শের জন্য যাচাইকরণ সঠিকতা এবং সংখ্যাসূচক সমতুল্য নোটবুকটিও পরীক্ষা করতে পারেন।

np.testing.assert_allclose(model_tf1.logs['lr'], model_tf2.logs['lr'])
np.testing.assert_allclose(model_tf1.logs['loss'], model_tf2.logs['loss'])
for step in range(step_num):
  for name in model_tf1.logs['layer_out'][step]:
    np.testing.assert_allclose(
        model_tf1.logs['layer_out'][step][name],
        model_tf2.logs['layer_out'][step][name])

ইউনিট পরীক্ষা

আপনার মাইগ্রেশন কোড ডিবাগ করতে সাহায্য করতে পারে এমন কয়েক ধরনের ইউনিট টেস্টিং আছে।

1. একক ফরোয়ার্ড পাস বৈধতা
2. কয়েকটি ধাপের জন্য মডেল প্রশিক্ষণ সংখ্যাসূচক সমতা যাচাই
3. বেঞ্চমার্ক অনুমান কর্মক্ষমতা
4. প্রশিক্ষিত মডেল স্থির এবং সাধারণ ডেটা পয়েন্টগুলিতে সঠিক ভবিষ্যদ্বাণী করে

আপনি বিভিন্ন কনফিগারেশন সহ মডেল পরীক্ষা করতে @parameterized.parameters ব্যবহার করতে পারেন। কোড নমুনা সহ বিশদ বিবরণ ।

মনে রাখবেন যে একই পরীক্ষার ক্ষেত্রে সেশন API এবং আগ্রহী সম্পাদন চালানো সম্ভব। নীচের কোড স্নিপেটগুলি দেখায় কিভাবে।

import unittest

class TestNumericalEquivalence(unittest.TestCase):

  # copied from code samples above
  def setup(self):
    # record statistics for 100 training steps
    step_num = 100

    # setup TF 1 model
    random_tool = v1.keras.utils.DeterministicRandomTestTool(mode='num_random_ops')
    with random_tool.scope():
      # run TF1.x code in graph mode with context management
      graph = tf.Graph()
      with graph.as_default(), tf.compat.v1.Session(graph=graph) as sess:
        self.model_tf1 = SimpleModelWrapper()
        # build the model
        inputs = tf.compat.v1.placeholder(tf.float32, shape=(None, params['input_size']))
        labels = tf.compat.v1.placeholder(tf.float32, shape=(None, params['num_classes']))
        spec = self.model_tf1.model_fn(inputs, labels, tf.estimator.ModeKeys.TRAIN, params)
        train_op = spec.train_op

        sess.run(tf.compat.v1.global_variables_initializer())
        for step in range(step_num):
          # log everything and update the model for one step
          logs, _ = sess.run(
              [self.model_tf1.logged_ops, train_op],
              feed_dict={inputs: fake_x, labels: fake_y})
          self.model_tf1.update_logs(logs)

    # setup TF2 model
    random_tool = v1.keras.utils.DeterministicRandomTestTool(mode='num_random_ops')
    with random_tool.scope():
      self.model_tf2 = SimpleModel(params)
      for step in range(step_num):
        self.model_tf2.train_step([fake_x, fake_y])

  def test_learning_rate(self):
    np.testing.assert_allclose(
        self.model_tf1.logs['lr'],
        self.model_tf2.logs['lr'])

  def test_training_loss(self):
    # adopt different tolerance strategies before and after 10 steps
    first_n_step = 10

    # abosolute difference is limited below 1e-5
    # set `equal_nan` to be False to detect potential NaN loss issues
    abosolute_tolerance = 1e-5
    np.testing.assert_allclose(
        actual=self.model_tf1.logs['loss'][:first_n_step],
        desired=self.model_tf2.logs['loss'][:first_n_step],
        atol=abosolute_tolerance,
        equal_nan=False)

    # relative difference is limited below 5%
    relative_tolerance = 0.05
    np.testing.assert_allclose(self.model_tf1.logs['loss'][first_n_step:],
                               self.model_tf2.logs['loss'][first_n_step:],
                               rtol=relative_tolerance,
                               equal_nan=False)

ডিবাগিং টুল

tf.প্রিন্ট

tf.print বনাম print/logging.info

• কনফিগারযোগ্য আর্গুমেন্টের সাথে, tf.print মুদ্রিত টেনসরগুলির জন্য প্রতিটি মাত্রার প্রথম এবং শেষ কয়েকটি উপাদান পুনরাবৃত্তভাবে প্রদর্শন করতে পারে। বিস্তারিত জানার জন্য API ডক্স চেক করুন.
• আগ্রহী সম্পাদনের জন্য, print এবং tf.print উভয়ই টেনসরের মান প্রিন্ট করে। কিন্তু print ডিভাইস থেকে হোস্ট কপি জড়িত হতে পারে, যা সম্ভাব্য আপনার কোড ধীর হতে পারে।
• tf.function ভিতরে ব্যবহার সহ গ্রাফ মোডের জন্য, আপনাকে প্রকৃত টেনসর মান প্রিন্ট করতে tf.print ব্যবহার করতে হবে। tf.print গ্রাফে একটি অপে কম্পাইল করা হয়, যেখানে print এবং logging.info শুধুমাত্র ট্রেসিং টাইমে লগ করে, যা প্রায়শই আপনি যা চান তা নয়।
• tf.print এছাড়াও tf.RaggedTensor এবং tf.sparse.SparseTensor এর মতো যৌগিক টেনসর মুদ্রণ সমর্থন করে।
• আপনি মেট্রিক্স এবং ভেরিয়েবল নিরীক্ষণ করতে একটি কলব্যাক ব্যবহার করতে পারেন। লগ ডিক্ট এবং self.model অ্যাট্রিবিউট সহ কাস্টম কলব্যাকগুলি কীভাবে ব্যবহার করবেন দয়া করে দেখুন৷

tf.print বনাম tf.function এর ভিতরে প্রিন্ট

# `print` prints info of tensor object
# `tf.print` prints the tensor value
@tf.function
def dummy_func(num):
  num += 1
  print(num)
  tf.print(num)
  return num

_ = dummy_func(tf.constant([1.0]))

# Output:
# Tensor("add:0", shape=(1,), dtype=float32)
# [2]

Tensor("add:0", shape=(1,), dtype=float32)
[2]

tf.distribute.Strategy

• যদি tf.function সম্বলিত tf.print কর্মীদের উপর চালানো হয়, উদাহরণস্বরূপ TPUStrategy বা ParameterServerStrategy ব্যবহার করার সময়, আপনাকে মুদ্রিত মানগুলি খুঁজে বের করতে কর্মী/প্যারামিটার সার্ভার লগগুলি পরীক্ষা করতে হবে।
• print বা logging.info এর জন্য, ParameterServerStrategy ব্যবহার করার সময় লগগুলি সমন্বয়কারীতে প্রিন্ট করা হবে এবং TPU ব্যবহার করার সময় STDOUT on worker0-এ লগ প্রিন্ট করা হবে।

tf.keras.মডেল

• অনুক্রমিক এবং কার্যকরী API মডেলগুলি ব্যবহার করার সময়, আপনি যদি মানগুলি মুদ্রণ করতে চান, যেমন, মডেল ইনপুট বা কিছু স্তরের পরে মধ্যবর্তী বৈশিষ্ট্যগুলি, আপনার কাছে নিম্নলিখিত বিকল্পগুলি রয়েছে।
  1. একটি কাস্টম স্তর লিখুন যা ইনপুটগুলিকে tf.print .প্রিন্ট করে।
  2. মডেল আউটপুটগুলিতে আপনি যে মধ্যবর্তী আউটপুটগুলি পরিদর্শন করতে চান তা অন্তর্ভুক্ত করুন।
• tf.keras.layers.Lambda স্তরগুলির (de)ক্রমিক সীমাবদ্ধতা রয়েছে৷ চেকপয়েন্ট লোডিং সমস্যা এড়াতে, পরিবর্তে একটি কাস্টম সাবক্লাসড লেয়ার লিখুন। আরো বিস্তারিত জানার জন্য API ডক্স চেক করুন.
• আপনি একটি tf.print এ মধ্যবর্তী আউটপুট tf.keras.callbacks.LambdaCallback .প্রিন্ট করতে পারবেন না যদি আপনার প্রকৃত মানগুলিতে অ্যাক্সেস না থাকে তবে পরিবর্তে শুধুমাত্র প্রতীকী কেরাস টেনসর বস্তুগুলিতে।

বিকল্প 1: একটি কাস্টম স্তর লিখুন

class PrintLayer(tf.keras.layers.Layer):
  def call(self, inputs):
    tf.print(inputs)
    return inputs

def get_model():
  inputs = tf.keras.layers.Input(shape=(1,))
  out_1 = tf.keras.layers.Dense(4)(inputs)
  out_2 = tf.keras.layers.Dense(1)(out_1)
  # use custom layer to tf.print intermediate features
  out_3 = PrintLayer()(out_2)
  model = tf.keras.Model(inputs=inputs, outputs=out_3)
  return model

model = get_model()
model.compile(optimizer="adam", loss="mse")
model.fit([1, 2, 3], [0.0, 0.0, 1.0])

[[-0.327884018]
 [-0.109294668]
 [-0.218589336]]
1/1 [==============================] - 0s 280ms/step - loss: 0.6077
<keras.callbacks.History at 0x7f63d46bf190>

বিকল্প 2: মডেল আউটপুটগুলিতে আপনি যে মধ্যবর্তী আউটপুটগুলি পরিদর্শন করতে চান তা অন্তর্ভুক্ত করুন।

মনে রাখবেন যে এই ধরনের ক্ষেত্রে, Model.fit ব্যবহার করার জন্য আপনার কিছু কাস্টমাইজেশনের প্রয়োজন হতে পারে।

def get_model():
  inputs = tf.keras.layers.Input(shape=(1,))
  out_1 = tf.keras.layers.Dense(4)(inputs)
  out_2 = tf.keras.layers.Dense(1)(out_1)
  # include intermediate values in model outputs
  model = tf.keras.Model(
      inputs=inputs,
      outputs={
          'inputs': inputs,
          'out_1': out_1,
          'out_2': out_2})
  return model

পিডিবি

ডিবাগিংয়ের জন্য মধ্যবর্তী মানগুলি পরীক্ষা করতে আপনি টার্মিনাল এবং Colab উভয় ক্ষেত্রেই pdb ব্যবহার করতে পারেন।

TensorBoard দিয়ে গ্রাফ ভিজ্যুয়ালাইজ করুন

আপনি TensorBoard দিয়ে TensorFlow গ্রাফ পরীক্ষা করতে পারেন। টেনসরবোর্ড কোলাবেও সমর্থিত । TensorBoard সারাংশ কল্পনা করার জন্য একটি দুর্দান্ত সরঞ্জাম। আপনি এটি ব্যবহার করতে পারেন শেখার হার, মডেল ওজন, গ্রেডিয়েন্ট স্কেল, প্রশিক্ষণ/বৈধকরণ মেট্রিক্স, এমনকি প্রশিক্ষণ প্রক্রিয়ার মাধ্যমে TF1.x মডেল এবং স্থানান্তরিত TF2 মডেলের মধ্যবর্তী আউটপুটগুলির মধ্যে তুলনা করতে এবং মানগুলি প্রত্যাশিত হিসাবে দেখায় কিনা তা দেখতে।

টেনসরফ্লো প্রোফাইলার

টেনসরফ্লো প্রোফাইলার আপনাকে জিপিইউ/টিপিইউ-তে এক্সিকিউশন টাইমলাইন কল্পনা করতে সাহায্য করতে পারে। আপনি এই Colab ডেমোটি এর প্রাথমিক ব্যবহারের জন্য দেখতে পারেন।

মাল্টিপ্রসেসরানার

MultiWorkerMirroredStrategy এবং ParameterServerStrategy এর সাথে ডিবাগ করার সময় MultiProcessRunner একটি দরকারী টুল। আপনি এর ব্যবহারের জন্য এই কংক্রিট উদাহরণটি দেখতে পারেন।

বিশেষত এই দুটি কৌশলের ক্ষেত্রে, আপনাকে সুপারিশ করা হচ্ছে 1) শুধুমাত্র তাদের প্রবাহকে কভার করার জন্য ইউনিট পরীক্ষাই নয়, 2) কিন্তু প্রতিবার যখন তারা চেষ্টা করে তখন প্রকৃত বিতরণ করা কাজ চালু করার জন্য ইউনিট পরীক্ষায় এটি ব্যবহার করে ব্যর্থতা পুনরুত্পাদন করার চেষ্টা করার জন্যও একটি ফিক্স