ดีบัก TF2 Migrated Training Pipeline

ดูบน TensorFlow.org

ทำงานใน Google Colab

ดูแหล่งที่มาบน GitHub

ดาวน์โหลดโน๊ตบุ๊ค

สมุดบันทึกนี้สาธิตวิธีการดีบักไปป์ไลน์การฝึกเมื่อย้ายไปยัง TF2 ประกอบด้วยองค์ประกอบดังต่อไปนี้:

1. ขั้นตอนที่แนะนำและตัวอย่างโค้ดสำหรับการดีบักไปป์ไลน์การฝึกอบรม
2. เครื่องมือสำหรับการดีบัก
3. แหล่งข้อมูลอื่นๆ ที่เกี่ยวข้อง

ข้อสันนิษฐานหนึ่งคือ คุณมีโค้ด TF1.x และโมเดลที่ผ่านการฝึกอบรมสำหรับการเปรียบเทียบ และคุณต้องการสร้างโมเดล TF2 ที่มีความแม่นยำในการตรวจสอบที่คล้ายคลึงกัน

โน้ตบุ๊กนี้ ไม่ ครอบคลุมถึงปัญหาด้านประสิทธิภาพการดีบักสำหรับความเร็วการฝึก/การอนุมาน หรือการใช้หน่วยความจำ

เวิร์กโฟลว์การดีบัก

ด้านล่างนี้คือเวิร์กโฟลว์ทั่วไปสำหรับการดีบักไปป์ไลน์การฝึกอบรม TF2 ของคุณ โปรดทราบว่าคุณไม่จำเป็นต้องทำตามขั้นตอนเหล่านี้ตามลำดับ คุณยังสามารถใช้วิธีการค้นหาแบบไบนารีที่คุณทดสอบโมเดลในขั้นตอนระหว่างทางและจำกัดขอบเขตการดีบักให้แคบลง

1. แก้ไขข้อผิดพลาดในการคอมไพล์และรันไทม์

2. การตรวจสอบการส่งต่อครั้งเดียว (ใน คู่มือ แยกต่างหาก )

   ก. บนอุปกรณ์ CPU เดียว

   • ตรวจสอบว่าตัวแปรถูกสร้างขึ้นเพียงครั้งเดียว
   • ตรวจสอบจำนวนตัวแปร ชื่อ และรูปร่างที่ตรงกัน
   • รีเซ็ตตัวแปรทั้งหมด ตรวจสอบการเทียบเท่าตัวเลขโดยปิดการสุ่มทั้งหมด
   • จัดแนวการสร้างตัวเลขสุ่ม ตรวจสอบความสมมูลเชิงตัวเลขในการอนุมาน
   • (ไม่บังคับ) โหลดจุดตรวจสอบอย่างถูกต้องและรุ่น TF1.x/TF2 สร้างเอาต์พุตที่เหมือนกัน

   ข. บนอุปกรณ์ GPU/TPU เดียว

   ค. ด้วยกลยุทธ์หลายอุปกรณ์

3. การฝึกแบบจำลองการตรวจสอบการสมมูลเชิงตัวเลขสำหรับสองสามขั้นตอน (ตัวอย่างโค้ดมีให้ด้านล่าง)

   ก. การตรวจสอบขั้นตอนการฝึกอบรมเดียวโดยใช้ข้อมูลขนาดเล็กและคงที่บนอุปกรณ์ CPU ตัวเดียว ให้ตรวจสอบความสมมูลเชิงตัวเลขสำหรับส่วนประกอบต่อไปนี้โดยเฉพาะ

   • การคำนวณการสูญเสีย
   • เมตริก
   • อัตราการเรียนรู้
   • การคำนวณและอัปเดตการไล่ระดับสี

   ข. ตรวจสอบสถิติหลังการฝึก 3 ขั้นตอนขึ้นไปเพื่อตรวจสอบพฤติกรรมของตัวเพิ่มประสิทธิภาพ เช่น โมเมนตัม โดยยังคงข้อมูลคงที่บนอุปกรณ์ที่มี CPU ตัวเดียว

   ค. บนอุปกรณ์ GPU/TPU เดียว

   ง. ด้วยกลยุทธ์หลายอุปกรณ์ (ตรวจสอบบทนำสำหรับ MultiProcessRunner ที่ด้านล่าง)

4. การทดสอบความครอบคลุมแบบ end-to-end บนชุดข้อมูลจริง

   ก. ตรวจสอบพฤติกรรมการฝึกด้วย TensorBoard

   • ใช้เครื่องมือเพิ่มประสิทธิภาพอย่างง่าย เช่น 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

การตรวจสอบการส่งต่อครั้งเดียว

การตรวจสอบการส่งต่อครั้งเดียว รวมถึงการโหลดจุดตรวจ ครอบคลุมอยู่ใน colab อื่น

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 ซึ่งใช้จำนวนของการดำเนินการสุ่ม stateful ที่สังเกตก่อนหน้านี้เป็นเมล็ดการดำเนินการ

สิ่งนี้ใช้กับทั้งการสุ่มเก็บสถานะที่ใช้สำหรับการสร้างและการเริ่มต้นตัวแปร และกับการดำเนินการสุ่มเก็บสถานะที่ใช้ในการคำนวณ (เช่น สำหรับเลเยอร์การเลื่อนออก)

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

tf.print vs print/logging.info

• ด้วยอาร์กิวเมนต์ที่กำหนดค่าได้ tf.print สามารถแสดงซ้ำองค์ประกอบแรกและสุดท้ายของแต่ละมิติสำหรับเทนเซอร์ที่พิมพ์ได้ ตรวจสอบ เอกสาร API สำหรับรายละเอียด
• สำหรับการดำเนินการที่กระตือรือร้น ทั้ง print และ tf.print พิมพ์ค่าของเทนเซอร์ แต่ print อาจเกี่ยวข้องกับการคัดลอกระหว่างอุปกรณ์ต่อโฮสต์ ซึ่งอาจทำให้โค้ดของคุณช้าลง
• สำหรับโหมดกราฟรวมถึงการใช้งานภายใน tf.function คุณต้องใช้ tf.print เพื่อพิมพ์ค่าเทนเซอร์จริง tf.print ถูกคอมไพล์เป็น op ในกราฟ ในขณะที่ print และ logging.info จะบันทึกเฉพาะเวลาที่ติดตาม ซึ่งมักไม่ใช่สิ่งที่คุณต้องการ
• tf.print ยังรองรับการพิมพ์เทนเซอร์แบบผสม เช่น tf.RaggedTensor และ tf.sparse.SparseTensor
• คุณยังสามารถใช้การเรียกกลับเพื่อตรวจสอบตัวชี้วัดและตัวแปรได้อีกด้วย โปรดตรวจสอบวิธีใช้การเรียกกลับที่กำหนดเองด้วย logs dict และ 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.กลยุทธ์

• หาก tf.function ที่มี tf.print ถูกเรียกใช้งานกับผู้ปฏิบัติงาน เช่น เมื่อใช้ TPUStrategy หรือ ParameterServerStrategy คุณต้องตรวจสอบบันทึกเซิร์ฟเวอร์ของผู้ปฏิบัติงาน/พารามิเตอร์เพื่อค้นหาค่าที่พิมพ์ออกมา
• สำหรับ print หรือ logging.info บันทึกจะถูกพิมพ์บนผู้ประสานงานเมื่อใช้ ParameterServerStrategy และบันทึกจะถูกพิมพ์บน STDOUT บน worker0 เมื่อใช้ TPU

tf.keras.รุ่น

• เมื่อใช้โมเดล Sequential และ Functional API หากคุณต้องการพิมพ์ค่า เช่น อินพุตของโมเดล หรือคุณสมบัติขั้นกลางหลังบางเลเยอร์ คุณมีตัวเลือกดังต่อไปนี้
  1. เขียนเลเยอร์ที่กำหนดเอง ที่ tf.print อินพุต
  2. รวมเอาท์พุตระดับกลางที่คุณต้องการตรวจสอบในเอาท์พุตแบบจำลอง
• tf.keras.layers.Lambda เลเยอร์มี (de) ข้อ จำกัด ในการทำให้เป็นอนุกรม เพื่อหลีกเลี่ยงปัญหาการโหลดด่าน ให้เขียนเลเยอร์ย่อยแบบกำหนดเองแทน ตรวจสอบ เอกสาร API สำหรับรายละเอียดเพิ่มเติม
• คุณไม่สามารถ tf.print เอาต์พุตระดับกลางใน tf.keras.callbacks.LambdaCallback หากคุณไม่มีสิทธิ์เข้าถึงค่าจริง แต่จะใช้ได้เฉพาะกับวัตถุ Keras tensor ที่เป็นสัญลักษณ์เท่านั้น

ตัวเลือกที่ 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

pdb

คุณสามารถใช้ pdb ทั้งในเทอร์มินัลและ Colab เพื่อตรวจสอบค่ากลางสำหรับการดีบัก

แสดงภาพกราฟด้วย TensorBoard

คุณสามารถ ตรวจสอบกราฟ TensorFlow ด้วย TensorBoard นอกจากนี้ TensorBoard ยัง รองรับใน colab TensorBoard เป็นเครื่องมือที่ยอดเยี่ยมในการแสดงภาพสรุป คุณสามารถใช้เพื่อเปรียบเทียบอัตราการเรียนรู้ น้ำหนักโมเดล สเกลการไล่ระดับสี เมตริกการฝึกอบรม/การตรวจสอบ หรือแม้แต่เอาต์พุตระดับกลางของโมเดลระหว่างโมเดล TF1.x และโมเดล TF2 ที่โอนย้ายผ่านกระบวนการฝึกอบรม และดูว่าค่าต่างๆ เป็นไปตามที่คาดไว้หรือไม่

ตัวสร้างโปรไฟล์ TensorFlow

TensorFlow Profiler สามารถช่วยให้คุณเห็นภาพไทม์ไลน์การดำเนินการบน GPU/TPU คุณสามารถดูการ สาธิต Colab สำหรับการใช้งานพื้นฐานได้

MultiProcessRunner

MultiProcessRunner เป็นเครื่องมือที่มีประโยชน์เมื่อทำการดีบักด้วย MultiWorkerMirroredStrategy และ ParameterServerStrategy คุณสามารถดู ตัวอย่างการใช้งานที่เป็นรูปธรรมนี้ ได้

โดยเฉพาะสำหรับกรณีของทั้งสองกลยุทธ์นี้ ขอแนะนำว่า 1) ไม่เพียงแต่มีการทดสอบหน่วยเพื่อให้ครอบคลุมโฟลว์ของพวกมัน 2) แต่ยังพยายามสร้างความล้มเหลวซ้ำโดยใช้มันในการทดสอบหน่วยเพื่อหลีกเลี่ยงการเริ่มงานแบบกระจายจริงทุกครั้งที่พยายาม การแก้ไข