Đào tạo tùy chỉnh với tf.distribute.Strategy

Xem trên TensorFlow.org

Chạy trong Google Colab

Xem nguồn trên GitHub

Tải xuống sổ ghi chép

Hướng dẫn này trình bày cách sử dụng tf.distribute.Strategy với các vòng huấn luyện tùy chỉnh. Chúng tôi sẽ đào tạo một mô hình CNN đơn giản trên tập dữ liệu MNIST thời trang. Tập dữ liệu MNIST thời trang chứa 60000 hình ảnh đoàn tàu có kích thước 28 x 28 và 10000 hình ảnh thử nghiệm có kích thước 28 x 28.

Chúng tôi đang sử dụng các vòng đào tạo tùy chỉnh để đào tạo mô hình của mình vì chúng mang lại cho chúng tôi sự linh hoạt và khả năng kiểm soát tốt hơn trong quá trình đào tạo. Hơn nữa, nó dễ dàng hơn để gỡ lỗi mô hình và vòng lặp đào tạo.

# Import TensorFlow
import tensorflow as tf

# Helper libraries
import numpy as np
import os

print(tf.__version__)

2.8.0-rc1

Tải xuống bộ dữ liệu MNIST thời trang

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)

Tạo chiến lược để phân phối các biến và biểu đồ

Chiến lược tf.distribute.MirroredStrategy hoạt động như thế nào?

• Tất cả các biến và đồ thị mô hình được sao chép trên các bản sao.
• Đầu vào được phân bổ đồng đều trên các bản sao.
• Mỗi bản sao sẽ tính toán tổn thất và độ dốc cho đầu vào mà nó nhận được.
• Các gradient được đồng bộ hóa trên tất cả các bản sao bằng cách tính tổng chúng.
• Sau khi đồng bộ hóa, cập nhật tương tự được thực hiện cho các bản sao của các biến trên mỗi bản sao.

# 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

Thiết lập đường dẫn đầu vào

Xuất biểu đồ và các biến sang định dạng SavedModel bất khả tri nền tảng. Sau khi mô hình của bạn được lưu, bạn có thể tải nó có hoặc không có phạm vi.

BUFFER_SIZE = len(train_images)

BATCH_SIZE_PER_REPLICA = 64
GLOBAL_BATCH_SIZE = BATCH_SIZE_PER_REPLICA * strategy.num_replicas_in_sync

EPOCHS = 10

Tạo tập dữ liệu và phân phối chúng:

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
        }
      }
    }
  }
}

Tạo mô hình

Tạo một mô hình bằng tf.keras.Sequential . Bạn cũng có thể sử dụng API phân lớp mô hình để thực hiện việc này.

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")

Xác định hàm mất mát

Thông thường, trên một máy duy nhất có 1 GPU / CPU, tổn thất được chia cho số lượng ví dụ trong lô đầu vào.

Vì vậy, tổn thất nên được tính như thế nào khi sử dụng tf.distribute.Strategy ?

• Ví dụ: giả sử bạn có 4 GPU và kích thước lô là 64. Một lô đầu vào được phân phối trên các bản sao (4 GPU), mỗi bản sao nhận được đầu vào có kích thước 16.

• Mô hình trên mỗi bản sao thực hiện chuyển tiếp với đầu vào tương ứng và tính toán tổn thất. Bây giờ, thay vì chia tổn thất cho số lượng ví dụ trong đầu vào tương ứng (BATCH_SIZE_PER_REPLICA = 16), tổn thất nên được chia cho GLOBAL_BATCH_SIZE (64).

Tại sao làm điều này?

• Điều này cần phải được thực hiện bởi vì sau khi các độ dốc được tính toán trên mỗi bản sao, chúng được đồng bộ hóa trên các bản sao bằng cách tổng hợp chúng.

Làm cách nào để thực hiện điều này trong TensorFlow?

• Nếu bạn đang viết một vòng lặp đào tạo tùy chỉnh, như trong hướng dẫn này, bạn nên tính tổng số lỗ theo ví dụ và chia tổng cho GLOBAL_BATCH_SIZE: scale_loss = tf.reduce_sum(loss) * (1. / GLOBAL_BATCH_SIZE) hoặc bạn có thể sử dụng tf.nn.compute_average_loss lấy tổn thất trên mỗi ví dụ, trọng số mẫu tùy chọn và GLOBAL_BATCH_SIZE làm đối số và trả về tổn thất theo tỷ lệ.

• Nếu bạn đang sử dụng tổn thất chính quy trong mô hình của mình thì bạn cần chia tỷ lệ giá trị tổn thất theo số lượng bản sao. Bạn có thể thực hiện việc này bằng cách sử dụng hàm tf.nn.scale_regularization_loss .

• Sử dụng tf.reduce_mean không được khuyến khích. Làm như vậy chia tổn thất theo kích thước thực tế của mỗi lô bản sao có thể thay đổi theo từng bước.

• Việc giảm và chia tỷ lệ này được thực hiện tự động trong keras model.compile và model.fit

• Nếu sử dụng các lớp tf.keras.losses (như trong ví dụ bên dưới), mức giảm tổn thất cần được chỉ định rõ ràng là một trong các NONE hoặc SUM . AUTO và SUM_OVER_BATCH_SIZE không được phép khi sử dụng với tf.distribute.Strategy . AUTO không được phép vì người dùng nên suy nghĩ rõ ràng về việc họ muốn giảm mức độ nào để đảm bảo nó là chính xác trong trường hợp được phân phối. SUM_OVER_BATCH_SIZE không được phép vì hiện tại nó sẽ chỉ chia cho mỗi kích thước lô bản sao và để lại phép chia theo số lượng bản sao cho người dùng, điều này có thể dễ bỏ sót. Vì vậy, thay vào đó, chúng tôi yêu cầu người dùng tự giảm một cách rõ ràng.

• Nếu labels là nhiều chiều, thì tính trung bình per_example_loss trên số phần tử trong mỗi mẫu. Ví dụ: nếu hình dạng của các predictions là (batch_size, H, W, n_classes) và labels là (batch_size, H, W) , bạn sẽ cần cập nhật per_example_loss như: 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)

Xác định các chỉ số để theo dõi tổn thất và độ chính xác

Các chỉ số này theo dõi sự mất mát của thử nghiệm và đào tạo và độ chính xác của thử nghiệm. Bạn có thể sử dụng .result() để nhận số liệu thống kê tích lũy bất kỳ lúc nào.

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',).

Vòng lặp đào tạo

# 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

Những điều cần lưu ý trong ví dụ trên:

• Chúng tôi đang lặp lại train_dist_dataset và test_dist_dataset bằng cách sử dụng cấu trúc for x in ...
• Tổn thất theo tỷ lệ là giá trị trả về của distributed_train_step . Giá trị này được tổng hợp giữa các bản sao bằng cách sử dụng lệnh gọi tf.distribute.Strategy.reduce và sau đó trên các lô bằng cách tính tổng giá trị trả về của các lệnh gọi tf.distribute.Strategy.reduce .
• tf.keras.Metrics nên được cập nhật bên trong train_step và test_step được thực thi bởi tf.distribute.Strategy.run . * tf.distribute.Strategy.run trả về kết quả từ mỗi bản sao cục bộ trong chiến lược và có nhiều cách để sử dụng kết quả này. Bạn có thể thực hiện tf.distribute.Strategy.reduce để nhận giá trị tổng hợp. Bạn cũng có thể thực hiện tf.distribute.Strategy.experimental_local_results để lấy danh sách các giá trị có trong kết quả, một giá trị cho mỗi bản sao cục bộ.

Khôi phục điểm kiểm tra và kiểm tra mới nhất

Mô hình được kiểm tra bằng tf.distribute.Strategy có thể được khôi phục có hoặc không có chiến lược.

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

Các cách thay thế để lặp qua tập dữ liệu

Sử dụng trình lặp

Nếu bạn muốn lặp qua một số bước nhất định mà không phải qua toàn bộ tập dữ liệu, bạn có thể tạo một trình vòng lặp bằng cách sử dụng lệnh gọi iter và lệnh gọi exp —— next trên trình vòng lặp. Bạn có thể chọn lặp lại tập dữ liệu cả bên trong và bên ngoài chức năng tf. Đây là một đoạn mã nhỏ thể hiện sự lặp lại của tập dữ liệu bên ngoài chức năng tf. bằng cách sử dụng một trình vòng lặp.

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

Lặp lại bên trong một chức năng tf.

Bạn cũng có thể lặp lại toàn bộ đầu vào train_dist_dataset bên trong một hàm tf. bằng cách sử dụng cấu trúc for x in ... hoặc bằng cách tạo các trình vòng lặp như chúng ta đã làm ở trên. Ví dụ dưới đây minh họa gói một kỷ nguyên huấn luyện trong một hàm tf. và lặp qua train_dist_dataset bên trong hàm.

@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

Theo dõi mất đào tạo qua các bản sao

Chúng tôi khuyên bạn không nên sử dụng tf.metrics.Mean để theo dõi tổn thất đào tạo trên các bản sao khác nhau, vì tính toán tỷ lệ tổn thất được thực hiện.

Ví dụ: nếu bạn điều hành một công việc đào tạo với các đặc điểm sau:

• Hai bản sao
• Hai mẫu được xử lý trên mỗi bản sao
• Giá trị tổn thất kết quả: [2, 3] và [4, 5] trên mỗi bản sao
• Kích thước lô toàn cầu = 4

Với chia tỷ lệ tổn thất, bạn tính toán giá trị tổn thất theo từng mẫu trên mỗi bản sao bằng cách cộng các giá trị tổn thất, sau đó chia cho kích thước lô toàn cầu. Trong trường hợp này: (2 + 3) / 4 = 1.25 và (4 + 5) / 4 = 2.25 .

Nếu bạn sử dụng tf.metrics.Mean để theo dõi tổn thất trên hai bản sao, kết quả là khác nhau. Trong ví dụ này, bạn có total là 3,50 và count là 2, dẫn đến total / count = 1,75 khi result() được gọi trên chỉ số. Tổn thất được tính toán bằng tf.keras.Metrics được chia tỷ lệ bằng một hệ số bổ sung bằng với số lượng bản sao được đồng bộ hóa.

Hướng dẫn và ví dụ

Dưới đây là một số ví dụ về việc sử dụng chiến lược phân phối với các vòng đào tạo tùy chỉnh:

1. Hướng dẫn đào tạo phân tán
2. Ví dụ về DenseNet sử dụng MirroredStrategy .
3. Ví dụ BERT được đào tạo bằng cách sử dụng MirroredStrategy và TPUStrategy . Ví dụ này đặc biệt hữu ích để hiểu cách tải từ một điểm kiểm tra và tạo các điểm kiểm tra định kỳ trong quá trình đào tạo phân tán, v.v.
4. Ví dụ NCF được đào tạo bằng cách sử dụng MirroredStrategy có thể được bật bằng cờ keras_use_ctl .
5. Ví dụ NMT được đào tạo bằng MirroredStrategy .

Các ví dụ khác được liệt kê trong Hướng dẫn chiến lược phân phối .

Bước tiếp theo

• Hãy dùng thử API tf.distribute.Strategy mới trên các mô hình của bạn.
• Truy cập phần Hiệu suất trong hướng dẫn để tìm hiểu thêm về các chiến lược và công cụ khác mà bạn có thể sử dụng để tối ưu hóa hiệu suất của các mô hình TensorFlow của mình.