ช่วยปกป้อง Great Barrier Reef กับ TensorFlow บน Kaggle เข้าร่วมท้าทาย

การฝึกอบรมแบบกำหนดเองด้วย 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

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

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

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