การฝึกอบรมแบบกำหนดเองด้วย tf.distribute.Strategy

ดูบน TensorFlow.org ทำงานใน Google Colab ดูแหล่งที่มาบน GitHub ดาวน์โหลดโน๊ตบุ๊ค

กวดวิชานี้จะแสดงให้เห็นถึงวิธีการใช้ tf.distribute.Strategy กับลูปการฝึกอบรมที่กำหนดเอง เราจะฝึกโมเดล CNN อย่างง่ายบนชุดข้อมูล MNIST ของแฟชั่น ชุดข้อมูลแฟชั่น MNIST ประกอบด้วยรูปภาพรถไฟ 60000 รูปขนาด 28 x 28 และรูปภาพทดสอบ 10000 รูปขนาด 28 x 28

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

# 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 คุณยังสามารถใช้ Model Subclassing 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 GPU) แต่ละแบบจำลองจะได้รับอินพุตขนาด 16

  • โมเดลบนแบบจำลองแต่ละอันจะส่ง Forward Pass ด้วยอินพุตที่เกี่ยวข้องและคำนวณการสูญเสีย ตอนนี้ แทนที่จะหารการสูญเสียด้วยจำนวนตัวอย่างในอินพุตที่เกี่ยวข้อง (BATCH_SIZE_PER_REPLICA = 16) การสูญเสียควรหารด้วย GLOBAL_BATCH_SIZE (64)

ทำไมทำเช่นนี้?

  • นี้จะต้องทำเพราะหลังจากที่ไล่ระดับสีได้มีการคำนวณในแต่ละแบบจำลองที่พวกเขาจะซิงค์แบบจำลองจากข้อสรุปพวกเขา

จะทำสิ่งนี้ใน TensorFlow ได้อย่างไร?

  • หากคุณกำลังเขียนห่วงการฝึกอบรมที่กำหนดเองเช่นในการกวดวิชานี้คุณควรจะสรุปต่อตัวอย่างเช่นการสูญเสียและแบ่งผลรวมโดย 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 หรือ SUM 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.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

สิ่งที่ควรทราบในตัวอย่างข้างต้น:

  • เรามีการทำซ้ำมากกว่า train_dist_dataset และ test_dist_dataset ใช้ for x in ... สร้าง
  • การสูญเสียปรับขนาดเป็นค่าตอบแทนของ distributed_train_step ค่านี้จะถูกรวบรวมจากแบบจำลองที่ใช้ tf.distribute.Strategy.reduce โทรแล้วทั่ว batches จากข้อสรุปค่าตอบแทนของ 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

วิธีอื่นในการวนซ้ำชุดข้อมูล

การใช้ตัววนซ้ำ

หากคุณต้องการที่จะย้ำกว่าจำนวนที่กำหนดขั้นตอนและไม่ผ่านชุดข้อมูลทั้งหมดที่คุณสามารถสร้าง iterator ใช้ 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 และ (4 + 5) / 4 = 2.25

ถ้าคุณใช้ tf.metrics.Mean เพื่อติดตามการสูญเสียทั้งสองแบบจำลองผลที่แตกต่างกัน ในตัวอย่างนี้คุณจะจบลงด้วยการ total 3.50 และ count 2 ซึ่งผลในการ total / count = 1.75 เมื่อ result() ถูกเรียกบนตัวชี้วัด การสูญเสียการคำนวณกับ tf.keras.Metrics จะถูกปรับขนาดโดยปัจจัยเพิ่มเติมที่จะเท่ากับจำนวนของแบบจำลองในการซิงค์

คู่มือและตัวอย่าง

ต่อไปนี้คือตัวอย่างบางส่วนสำหรับการใช้กลยุทธ์การกระจายกับลูปการฝึกแบบกำหนดเอง:

  1. คู่มือการอบรมแบบกระจาย
  2. DenseNet ตัวอย่างการใช้ MirroredStrategy
  3. BERT ตัวอย่างเช่นการฝึกอบรมโดยใช้ MirroredStrategy และ TPUStrategy ตัวอย่างนี้มีประโยชน์อย่างยิ่งในการทำความเข้าใจวิธีการโหลดจากจุดตรวจ และสร้างจุดตรวจเป็นระยะระหว่างการฝึกอบรมแบบกระจาย ฯลฯ
  4. NCF ตัวอย่างเช่นการฝึกอบรมโดยใช้ MirroredStrategy ที่สามารถเปิดใช้งานโดยใช้ keras_use_ctl ธง
  5. NMT ตัวอย่างเช่นการฝึกอบรมโดยใช้ MirroredStrategy

ตัวอย่างอื่น ๆ ที่ระบุไว้ใน คำแนะนำกลยุทธ์การจัดจำหน่าย

ขั้นตอนถัดไป