آموزش سفارشی با 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.8.0-rc1

مجموعه داده مد 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()

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 که دارای پلتفرم آگنوستیک هستند صادر کنید. بعد از اینکه مدل شما ذخیره شد، می توانید آن را با یا بدون Scope بارگذاری کنید.

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)

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

مدل را ایجاد کنید

یک مدل با استفاده از 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 پردازنده گرافیکی و اندازه دسته ای 64 دارید. یک دسته ورودی در بین ماکت ها (4 پردازنده گرافیکی) توزیع می شود، که هر ماکت ورودی اندازه 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 استفاده کنید. 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.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

مواردی که در مثال بالا باید به آن توجه کنید:

• ما در حال تکرار روی train_dist_dataset و test_dist_dataset با استفاده از for x in ... هستیم.
• ضرر مقیاس شده، مقدار بازگشتی distributed_train_step است. این مقدار با استفاده از تماس tf.distribute.Strategy.reduce و سپس با جمع کردن مقدار بازگشتی تماس‌های 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 را انجام دهید تا لیست مقادیر موجود در نتیجه را به دست آورید، یک عدد برای هر ماکت محلی.

آخرین بازرسی و تست را بازیابی کنید

یک مدل بازرسی با یک 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.0199966430664

روش های جایگزین برای تکرار روی یک مجموعه داده

استفاده از تکرار کننده ها

اگر می‌خواهید در تعداد معینی از مراحل و نه از طریق کل مجموعه داده تکرار کنید، می‌توانید با استفاده از iter و فراخوانی صریح next در تکرارکننده، یک تکرارکننده ایجاد کنید. می‌توانید انتخاب کنید که روی مجموعه داده‌ها هم در داخل و هم در خارج از tf.function تکرار شود. در اینجا یک قطعه کوچک وجود دارد که تکرار مجموعه داده خارج از تابع tf. با استفاده از یک تکرار کننده را نشان می دهد.

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

تکرار در داخل یک تابع tf

همچنین می‌توانید کل ورودی train_dist_dataset را در داخل یک tf.function با استفاده از for x in ... یا با ایجاد تکرارکننده‌هایی مانند آنچه در بالا انجام دادیم، تکرار کنید. مثال زیر پیچیدن یک دوره آموزشی در یک تابع tf. و تکرار روی 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()

/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

ردیابی از دست دادن آموزش در بین کپی ها

ما استفاده از 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 می گیرید، که در صورت فراخوانی result() در متریک، نتیجه total / count = 1.75 است. ضرر محاسبه شده با tf.keras.Metrics با یک عامل اضافی که برابر با تعداد تکرارهای همگام است، مقیاس بندی می شود.

راهنما و مثال

در اینجا چند مثال برای استفاده از استراتژی توزیع با حلقه های آموزشی سفارشی آورده شده است:

1. راهنمای آموزشی توزیع شده
2. مثال DenseNet با استفاده از MirroredStrategy .
3. نمونه BERT با استفاده از MirroredStrategy و TPUStrategy آموزش دیده است. این مثال به ویژه برای درک نحوه بارگیری از یک ایست بازرسی و ایجاد پست های بازرسی دوره ای در طول آموزش توزیع شده و غیره مفید است.
4. نمونه NCF با استفاده از MirroredStrategy آموزش داده شده است که می تواند با استفاده از پرچم keras_use_ctl فعال شود.
5. نمونه NMT با استفاده از MirroredStrategy آموزش داده شده است.

نمونه های بیشتر در راهنمای استراتژی توزیع فهرست شده است.

مراحل بعدی

• tf.distribute.Strategy API جدید را در مدل های خود امتحان کنید.
• برای کسب اطلاعات بیشتر در مورد سایر استراتژی ها و ابزارهایی که می توانید برای بهینه سازی عملکرد مدل های TensorFlow خود از آنها استفاده کنید، از بخش عملکرد در راهنما دیدن کنید.