אימון מותאם אישית עם tf.distribute.Strategy

מדריך זה מדגים כיצד להשתמש ב- tf.distribute.Strategy עם לולאות אימון מותאמות אישית. אנו נאמן מודל פשוט של CNN על מערך הנתונים האופנה של MNIST. מערך הנתונים האופנה של MNIST מכיל 60,000 תמונות רכבת בגודל 28 x 28 ו-10,000 תמונות בדיקה בגודל 28 x 28.

אנו משתמשים בלולאות אימון מותאמות אישית כדי לאמן את המודל שלנו מכיוון שהם נותנים לנו גמישות ושליטה רבה יותר באימונים. יתר על כן, קל יותר לנפות באגים במודל ובלולאת האימון.

# Import TensorFlow
import tensorflow as tf

# Helper libraries
import numpy as np
import os

print(tf.__version__)

2.8.0-rc1

הורד את מערך הנתונים של fashion 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 האגנסטי לפלטפורמה. לאחר שמירת הדגם שלך, תוכל לטעון אותו עם או בלי ההיקף.

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 . אתה יכול גם להשתמש ב-API של Model Subclassing כדי לעשות זאת.

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 GPUs), כל העתק מקבל קלט בגודל 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 אינו מומלץ. פעולה זו מחלקת את ההפסד לפי גודל אצווה בפועל לכל העתק, שעשוי להשתנות שלב לשלב.

• הקטנה ושינוי קנה מידה זה מתבצעים באופן אוטומטי ב- 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)

  זהירות: ודא את צורת האובדן שלך . פונקציות הפסד ב- tf.losses / tf.keras.losses בדרך כלל את הממוצע על פני הממד האחרון של הקלט. מחלקות ההפסד עוטפות את הפונקציות הללו. מעבר reduction=Reduction.NONE .NONE בעת יצירת מופע של מחלקת הפסד פירושו "ללא הפחתה נוספת ". עבור הפסדים קטגוריים עם צורת קלט לדוגמה של [batch, W, H, n_classes] ממד n_classes מצטמצם. עבור הפסדים נקודתיים כמו losses.mean_squared_error או losses.binary_crossentropy ציר דמה כך ש- [batch, W, H, 1] מצטמצם ל- [batch, W, H] . ללא ציר הדמה [batch, W, H] יצטמצם באופן שגוי ל- [batch, W] .

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 באמצעות a for x in ... construct.
• ההפסד בקנה מידה הוא ערך ההחזר של ה- 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.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.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.function ואיטרציה על 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.keras.Metrics כדי לעקוב אחר ערכים לכל דוגמה ולהימנע מערכים שנצברו בתוך עותק.

אנו לא ממליצים להשתמש ב- 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 .

דוגמאות נוספות המפורטות במדריך אסטרטגיית ההפצה .

הצעדים הבאים

• נסה את ה-API החדש של tf.distribute.Strategy בדגמים שלך.
• בקר בסעיף ביצועים במדריך כדי ללמוד עוד על אסטרטגיות וכלים אחרים שבהם אתה יכול להשתמש כדי לייעל את הביצועים של דגמי TensorFlow שלך.