דף זה תורגם על ידי Cloud Translation API.
Switch to English

הכשרה רב עובדים עם קרס

צפה ב TensorFlow.org הפעל ב- Google Colab צפה במקור ב- GitHub הורד מחברת

סקירה כללית

מדריך זה מדגים הכשרה מבוזרת מרובת עובדים עם מודל tf.distribute.Strategy באמצעות tf.distribute.Strategy API, ספציפית tf.distribute.experimental.MultiWorkerMirroredStrategy . בעזרת אסטרטגיה זו, מודל Keras שנועד לפעול על עובד יחיד יכול לעבוד בצורה חלקה על עובדים מרובים תוך שינוי קוד מינימלי.

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

להכין

ראשית, הגדר את TensorFlow ואת היבוא הדרוש.

 import os
import tensorflow as tf
import numpy as np
 

מכין מערך נתונים

עכשיו, בואו נכין את מערך הנתונים של MNIST. מערך הנתונים של MNIST כולל 60,000 דוגמאות הדרכה ו -10,000 דוגמאות מבחן של הספרות בכתב יד 0–9, המעוצבות כתמונות מונוכרומיות של 28X28 פיקסלים. בדוגמה זו ניקח את החלק ההדרכה של מערכי הנתונים להפגנה.

 def mnist_dataset(batch_size):
  (x_train, y_train), _ = tf.keras.datasets.mnist.load_data()
  # The `x` arrays are in uint8 and have values in the range [0, 255].
  # We need to convert them to float32 with values in the range [0, 1]
  x_train = x_train / np.float32(255)
  y_train = y_train.astype(np.int64)
  train_dataset = tf.data.Dataset.from_tensor_slices(
      (x_train, y_train)).shuffle(60000).repeat().batch(batch_size)
  return train_dataset
 

בנה את דגם Keras

כאן אנו משתמשים ב- tf.keras.Sequential API כדי לבנות ולהרכיב מודל Keras רשתות עצביות פשוטות ומפותלות לאימונים עם מערך הנתונים של MNIST.

 def build_and_compile_cnn_model():
  model = tf.keras.Sequential([
      tf.keras.Input(shape=(28, 28)),
      tf.keras.layers.Reshape(target_shape=(28, 28, 1)),
      tf.keras.layers.Conv2D(32, 3, activation='relu'),
      tf.keras.layers.Flatten(),
      tf.keras.layers.Dense(128, activation='relu'),
      tf.keras.layers.Dense(10)
  ])
  model.compile(
      loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
      optimizer=tf.keras.optimizers.SGD(learning_rate=0.001),
      metrics=['accuracy'])
  return model
 

ננסה תחילה לאמן את המודל למספר קטן של תקופות ונבחן בתוצאות אצל עובד יחיד כדי לוודא שהכל עובד כראוי. עליכם לצפות לראות שהאובדן נשמט ודיוק מתקרבים ל 1.0 ככל שמתקדמים בתקופה.

 per_worker_batch_size = 64
single_worker_dataset = mnist_dataset(per_worker_batch_size)
single_worker_model = build_and_compile_cnn_model()
single_worker_model.fit(single_worker_dataset, epochs=3, steps_per_epoch=70)
 
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 0s 0us/step
Epoch 1/3
70/70 [==============================] - 0s 2ms/step - loss: 2.2701 - accuracy: 0.2451
Epoch 2/3
70/70 [==============================] - 0s 2ms/step - loss: 2.1827 - accuracy: 0.4777
Epoch 3/3
70/70 [==============================] - 0s 2ms/step - loss: 2.0865 - accuracy: 0.5955

<tensorflow.python.keras.callbacks.History at 0x7fc59381ac50>

תצורת רב עובדים

עכשיו בואו ניכנס לעולם ההכשרה הרב-עובדים. ב- TensorFlow, משתנה הסביבה TF_CONFIG נדרש לאימונים במספר מכונות, שלכל אחת מהן אולי יש תפקיד שונה. TF_CONFIG הוא מחרוזת JSON המשמשת לציון תצורת האשכול בכל עובד שהוא חלק מהאשכול.

ישנם שני רכיבים של TF_CONFIG : cluster task . cluster מספק מידע על אשכול ההדרכה שהוא דיקט המורכב מסוגים שונים של משרות כמו worker . באימונים רב עובדים עם MultiWorkerMirroredStrategy , יש בדרך כלל worker אחד שלוקח על עצמו קצת יותר אחריות כמו שמירת מחסום וכתיבת קובץ סיכום עבור TensorBoard בנוסף למה worker רגיל עושה. עובד כזה מכונה העובד chief , ונהוג worker עם index 0 ימונה worker הראשי (למעשה כך מיושם tf.distribute.Strategy ). task מצד שני מספקת מידע על המשימה הנוכחית. cluster הרכיבים הראשון זהה לכל העובדים, task הרכיבים השנייה שונה בכל עובד ומציינת את type index של אותו עובד.

בדוגמה זו, הגדרנו את type המשימה "worker" ואת index המשימות ל 0 . המשמעות היא שהמכונה שיש לה הגדרה כזו היא העובדת הראשונה, שתמונה כעובדת הראשית ותעשה יותר עבודה מאשר עובדים אחרים. שים לב שמכונות אחרות יצטרכו להגדיר גם משתנה סביבתי TF_CONFIG להיות אותו TF_CONFIG cluster , אך type משימה שונה או index משימה, תלוי בתפקידי המכונות הללו.

לשם המחשה, מופעי הדרכה זו איך אפשר להגדיר TF_CONFIG עם 2 עובד על localhost . בפועל, המשתמשים היו יוצרים עובדים מרובים בכתובות / יציאות IP חיצוניות, TF_CONFIG על כל עובד כראוי.

 os.environ['TF_CONFIG'] = json.dumps({
    'cluster': {
        'worker': ["localhost:12345", "localhost:23456"]
    },
    'task': {'type': 'worker', 'index': 0}
})
 

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

בחר באסטרטגיה הנכונה

ב- TensorFlow, הכשרה מבוזרת מורכבת מאימונים סינכרוניים, בהם סנכרון שלבי ההדרכה בין העובדים והעתקים, ואימונים אסינכרוניים, בהם צעדי ההדרכה אינם מסונכרנים בקפדנות.

MultiWorkerMirroredStrategy , שהיא האסטרטגיה המומלצת להכשרה רב עובדים סינכרונית. כדי לאמן את המודל, השתמש במופע של tf.distribute.experimental.MultiWorkerMirroredStrategy . MultiWorkerMirroredStrategy יוצר עותקים של כל המשתנים בשכבות הדגם בכל מכשיר בכל העובדים. הוא משתמש ב- CollectiveOps , מערכת TensorFlow לתקשורת קולקטיבית, כדי לצבור צבעי צבע ושמירה על המשתנים בסנכרון. המדריך tf.distribute.Strategy כולל פרטים נוספים על אסטרטגיה זו.

 strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy()
 
WARNING:tensorflow:Collective ops is not configured at program startup. Some performance features may not be enabled.
INFO:tensorflow:Using MirroredStrategy with devices ('/device:GPU:0',)
INFO:tensorflow:Single-worker MultiWorkerMirroredStrategy with local_devices = ('/device:GPU:0',), communication = CollectiveCommunication.AUTO

MultiWorkerMirroredStrategy מספק יישומים מרובים באמצעות הפרמטר CollectiveCommunication . RING מיישם קולקטיבים מבוססי טבעת המשתמשים ב- gRPC כשכבת התקשורת בין-לארח. NCCL משתמש ב- NCCL של Nvidia כדי ליישם קולקטיבים. AUTO מגן על הבחירה בזמן ההפעלה. הבחירה הטובה ביותר של יישום קולקטיבי תלויה במספר GPUs ובסוגם, ובקשרים בין חיבורי הרשת באשכול.

הרכבת הדגם בעזרת MultiWorkerMirroredStrategy

עם שילוב ה- tf.distribute.Strategy API ל- tf.keras , השינוי היחיד tf.keras על מנת להפיץ את ההדרכה לרב עובדים הוא סגירת בניית הדגם ו- model.compile() להתקשר בתוך strategy.scope() . היקף אסטרטגיית ההפצה מכתיב כיצד והיכן נוצרים המשתנים, ובמקרה MultiWorkerMirroredStrategy , המשתנים שנוצרו הם MirroredVariable , והם משוכפלים על כל אחד מהעובדים.

 num_workers = 4

# Here the batch size scales up by number of workers since 
# `tf.data.Dataset.batch` expects the global batch size. Previously we used 64, 
# and now this becomes 128.
global_batch_size = per_worker_batch_size * num_workers
multi_worker_dataset = mnist_dataset(global_batch_size)

with strategy.scope():
  # Model building/compiling need to be within `strategy.scope()`.
  multi_worker_model = build_and_compile_cnn_model()

# Keras' `model.fit()` trains the model with specified number of epochs and
# number of steps per epoch. Note that the numbers here are for demonstration
# purposes only and may not sufficiently produce a model with good quality.
multi_worker_model.fit(multi_worker_dataset, epochs=3, steps_per_epoch=70)
 
Epoch 1/3
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/data/ops/multi_device_iterator_ops.py:601: get_next_as_optional (from tensorflow.python.data.ops.iterator_ops) is deprecated and will be removed in a future version.
Instructions for updating:
Use `tf.data.Iterator.get_next_as_optional()` instead.
70/70 [==============================] - 0s 3ms/step - loss: 2.2682 - accuracy: 0.2265
Epoch 2/3
70/70 [==============================] - 0s 3ms/step - loss: 2.1714 - accuracy: 0.4954
Epoch 3/3
70/70 [==============================] - 0s 3ms/step - loss: 2.0638 - accuracy: 0.6232

<tensorflow.python.keras.callbacks.History at 0x7fc5f4f062e8>

גירוד נתונים וגודל אצווה

באימונים מרובי עובדים עם MultiWorkerMirroredStrategy , יש צורך בהגנה של מערך הנתונים כדי להבטיח התכנסות וביצועים. עם זאת, שים לב כי בקטע הקוד שלמעלה, ערכות הנתונים מועברות ישירות ל- model.fit() מבלי להזדקק model.fit() ; הסיבה לכך היא ש- tf.distribute.Strategy API דואג אוטומטית לגלישת הנתונים. זה מרסק את מערך הנתונים ברמת הקובץ שעלול ליצור קרשים מוטועים. במקרים קיצוניים שבהם יש רק קובץ אחד, רק החרץ הראשון (כלומר עובד) יקבל נתוני הכשרה או הערכה וכתוצאה מכך כל העובדים יקבלו שגיאות.

אם אתה מעדיף סריג ידני לאימוניך, ניתן לכבות את tf.data.experimental.DistributeOptions באמצעות tf.data.experimental.DistributeOptions api. באופן קונקרטי,

 options = tf.data.Options()
options.experimental_distribute.auto_shard_policy = tf.data.experimental.AutoShardPolicy.OFF
dataset_no_auto_shard = multi_worker_dataset.with_options(options)
 

דבר נוסף שיש לשים לב אליו הוא גודל האצווה עבור datasets . בקטע הקוד שלמעלה אנו משתמשים ב- global_batch_size = per_worker_batch_size * num_workers , שהוא num_workers גדול פי כמה מהמקרה של עובד יחיד, מכיוון שהאפקטיבי לכל אצווה עובד הוא גודל האצווה הגלובלי (הפרמטר שהועבר ב- tf.data.Dataset.batch() ) מחולק במספר העובדים, ועם שינוי זה אנו שומרים על גודל האצווה לכל עובד זהה tf.data.Dataset.batch() .

הַעֲרָכָה

אם תעביר validation_data ל- model.fit , הוא יחליף בין אימונים והערכה לכל תקופה. ההערכה שלוקחת נתוני validation_data מופצת בכל אותה קבוצה של עובדים ותוצאות ההערכה מצטברות וזמינות עבור כל העובדים. בדומה לאימונים, מערך האימות מופרד אוטומטית ברמת הקובץ. עליך להגדיר גודל אצווה גלובלי בנתוני האימות ולהגדיר validation_steps . מומלץ לערוך מערך נתונים חוזר.

לחלופין, אתה יכול גם ליצור משימה אחרת הקוראת מעת לעת מחסומי ביקורת ומריצה את ההערכה. זה מה שעושה Estimator. אך זו אינה דרך מומלצת לבצע הערכה וכך פרטיה מושמטים.

נְבוּאָה

נכון לעכשיו model.predict לא עובד עם MultiWorkerMirroredStrategy.

ביצועים

כעת יש לך דגם Keras שמוגדר לפעול במספר עובדים עם MultiWorkerMirroredStrategy . אתה יכול לנסות את הטכניקות הבאות כדי לצבוט את הביצועים של אימונים עובדים רבים באמצעות MultiWorkerMirroredStrategy .

  • MultiWorkerMirroredStrategy מספקת יישומי תקשורת קולקטיביים מרובים. RING מיישם קולקטיבים מבוססי טבעת המשתמשים ב- gRPC כשכבת התקשורת בין-לארח. NCCL משתמש ב- NCCL של Nvidia כדי ליישם קולקטיבים. AUTO מגן על הבחירה בזמן ההפעלה. הבחירה הטובה ביותר של יישום קולקטיבי תלויה במספר GPUs ובסוגם, ובקשרים בין חיבורי הרשת באשכול. כדי לבטל את הבחירה האוטומטית, ציין ערך תקף לפרמטר communication של MultiWorkerMirroredStrategy של MultiWorkerMirroredStrategy , לדוגמה, communication=tf.distribute.experimental.CollectiveCommunication.NCCL .
  • tf.float את המשתנים ל- tf.float במידת האפשר. המודל הרשמי של ResNet כולל דוגמא כיצד ניתן לעשות זאת.

סובלנות לתקלה

באימונים סינכרוניים, האשכול ייכשל אם אחד העובדים ייכשל ולא קיים מנגנון התאוששות כישלונות. השימוש ב Keras עם tf.distribute.Strategy מגיע עם היתרון של סובלנות לתקלות במקרים בהם עובדים מתים או אינם יציבים בדרך אחרת. אנו עושים זאת על ידי שמירה על מצב האימונים במערכת הקבצים המופצת לבחירתך, כך לאחר הפעלה מחדש של המופע שנכשל בעבר או שהוסרו לפני כן, מצב ההדרכה מתאושש.

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

התקנה חוזרת של ModelCheckpoint

ModelCheckpoint חוזרת של ModelCheckpoint אינה מספקת עוד פונקציונליות לסובלנות תקלות, אנא השתמש BackupAndRestore .

ניתן עדיין להשתמש ModelCheckpoint ה- ModelCheckpoint לשמירת נקודות ביקורת. אך עם זאת, אם האימונים הופרעו או הסתיימו בהצלחה, על מנת להמשיך להתאמן ממחסום, המשתמש אחראי לטעון את הדגם באופן ידני. אופציונלי המשתמש יכול לבחור לשמור ולשחזר דגם / משקולות מחוץ להתקשרות של ModelCheckpoint .

שמירת וטעינה של הדגם

כדי לשמור את הדגם שלך באמצעות model.save או tf.saved_model.save , היעד לחיסכון צריך להיות שונה עבור כל עובד. על העובדים שאינם עובדים ראשיים, תצטרך לשמור את המודל בספרייה זמנית, ועל המפקד תצטרך לשמור בספריית הדגמים המסופקת. הספריות הזמניות של העובד צריכות להיות ייחודיות כדי למנוע טעויות הנובעות מרובות עובדים המנסים לכתוב לאותו מיקום. הדגם שנשמר בכל הספריות זהה ובדרך כלל יש להפנות רק לדגם שנשמר על ידי המנהל לצורך שחזור או הגשה. אנו ממליצים שיהיה לכם הגיון ניקוי כלשהו אשר מוחק את הספריות הזמניות שנוצרו על ידי העובדים לאחר סיום הכשרתם.

הסיבה שאתה צריך לחסוך על הצ'יף והעובדים בו זמנית היא מכיוון שאתה יכול לצבור משתנים במהלך בדיקת המחאה המחייבת גם את העובד וגם את העובדים להשתתף בפרוטוקול התקשורת allreduce. מצד שני, מתן אפשרות לעובד ולמנהל לחסוך באותה ספריית דגמים תביא לשגיאות עקב מחלוקת.

בעזרת MultiWorkerMirroredStrategy , התוכנית מופעלת על כל עובד, וכדי לדעת אם העובד הנוכחי הוא הראשי, אנו מנצלים את אובייקט פותר האשכול שיש לו תכונות task_type ו- task_id . task_type אומר לך מה העבודה הנוכחית (למשל 'עובד') ו- task_id אומר לך את המזהה של העובד. העובד עם מספר 0 מסומן כעובד הראשי.

בקטע הקוד שלהלן, write_filepath מספק את נתיב הקובץ לכתיבה, התלוי במזהה העובד. במקרה של ראש (עובד עם מספר 0) הוא כותב לנתיב הקובץ המקורי; עבור אחרים זה יוצר ספרייה זמנית (עם מזהה בנתיב הספרייה) לכתיבה:

 model_path = '/tmp/keras-model'

def _is_chief(task_type, task_id):
  # If `task_type` is None, this may be operating as single worker, which works 
  # effectively as chief.
  return task_type is None or task_type == 'chief' or (
            task_type == 'worker' and task_id == 0)

def _get_temp_dir(dirpath, task_id):
  base_dirpath = 'workertemp_' + str(task_id)
  temp_dir = os.path.join(dirpath, base_dirpath)
  tf.io.gfile.makedirs(temp_dir)
  return temp_dir

def write_filepath(filepath, task_type, task_id):
  dirpath = os.path.dirname(filepath)
  base = os.path.basename(filepath)
  if not _is_chief(task_type, task_id):
    dirpath = _get_temp_dir(dirpath, task_id)
  return os.path.join(dirpath, base)

task_type, task_id = (strategy.cluster_resolver.task_type,
                      strategy.cluster_resolver.task_id)
write_model_path = write_filepath(model_path, task_type, task_id)
 

עם זה, אתה מוכן כעת לחסוך:

 multi_worker_model.save(write_model_path)
 
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Model.state_updates (from tensorflow.python.keras.engine.training) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Layer.updates (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
INFO:tensorflow:Assets written to: /tmp/keras-model/assets

כפי שתיארנו לעיל, בהמשך יש לטעון את הדגם רק מהראש שנשמר אליו, אז בואו נסלק את הזמניות שעובדות הלא-ראשי הצילו:

 if not _is_chief(task_type, task_id):
  tf.io.gfile.rmtree(os.path.dirname(write_model_path))
 

כעת, כשמגיע הזמן לטעון, בואו להשתמש בממשק API נוח tf.keras.models.load_model , ונמשיך בעבודה נוספת. כאן אנו מניחים להשתמש בעובד יחיד רק כדי לטעון ולהמשיך באימונים, ובמקרה כזה אינך מתקשר ל- tf.keras.models.load_model בתוך strategy.scope() אחר. tf.keras.models.load_model strategy.scope() .

 loaded_model = tf.keras.models.load_model(model_path)

# Now that we have the model restored, and can continue with the training.
loaded_model.fit(single_worker_dataset, epochs=2, steps_per_epoch=20)
 
Epoch 1/2
20/20 [==============================] - 0s 2ms/step - loss: 1.9825 - accuracy: 0.1102
Epoch 2/2
20/20 [==============================] - 0s 2ms/step - loss: 1.9367 - accuracy: 0.1117

<tensorflow.python.keras.callbacks.History at 0x7fc5f4b0d8d0>

שמירת מחסום ושיקום

מצד שני, נקודות בדיקה מאפשרות לשמור את משקולות הדגם ולהחזיר אותן מבלי שתצטרכו להציל את כל הדגם. כאן תיצור tf.train.Checkpoint אחד tf.train.Checkpoint אחר הדגם, שמנוהל על ידי tf.train.CheckpointManager כך שרק המחסום האחרון יישמר.

 checkpoint_dir = '/tmp/ckpt'

checkpoint = tf.train.Checkpoint(model=multi_worker_model)
write_checkpoint_dir = write_filepath(checkpoint_dir, task_type, task_id)
checkpoint_manager = tf.train.CheckpointManager(
  checkpoint, directory=write_checkpoint_dir, max_to_keep=1)
 

לאחר הגדרת ה- CheckpointManager , אתה מוכן כעת לשמור ולהסיר את המחסומים שעובדים שאינם ראשי נשמרו.

 checkpoint_manager.save()
if not _is_chief(task_type, task_id):
  tf.io.gfile.rmtree(write_checkpoint_dir)
 

כעת, כשאתה צריך לשחזר, אתה יכול למצוא את המחסום האחרון שנשמר באמצעות פונקציה נוחה tf.train.latest_checkpoint . לאחר שחזור המחסום תוכלו להמשיך באימונים.

 latest_checkpoint = tf.train.latest_checkpoint(checkpoint_dir)
checkpoint.restore(latest_checkpoint)
multi_worker_model.fit(multi_worker_dataset, epochs=2, steps_per_epoch=20)
 
Epoch 1/2
20/20 [==============================] - 0s 3ms/step - loss: 1.9841 - accuracy: 0.6561
Epoch 2/2
20/20 [==============================] - 0s 3ms/step - loss: 1.9445 - accuracy: 0.6805

<tensorflow.python.keras.callbacks.History at 0x7fc5f49d9d30>

BackupAndRestore התקשרות חוזרת

BackupAndRestore התקשרות מספקת פונקציונליות עמידות בפני תקלות, באמצעות גיבוי דגם ומספר עידן הנוכחי בקובץ במחסום ארעי תחת backup_dir טיעון כדי BackupAndRestore . זה נעשה בסוף כל תקופה.

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

כדי להשתמש בו, tf.keras.callbacks.experimental.BackupAndRestore מופע של tf.keras.callbacks.experimental.BackupAndRestore tf.keras.Model.fit() בשיחת tf.keras.Model.fit() .

עם MultiWorkerMirroredStrategy, אם עובד מופרע, האשכול כולו מושהה עד להפעלה מחדש של העובד. עובדים אחרים יופעלו גם הם מחדש, והעובד שהופרע מצטרף לאשכול. לאחר מכן, כל עובד קורא את קובץ המחסום שנשמר בעבר ומרים את מצבו הקודם, ובכך מאפשר לאשכול לחזור לסנכרון. ואז האימונים ממשיכים.

BackupAndRestore התקשרות חוזרת משתמשת ב- CheckpointManager כדי לשמור ולשחזר את מצב האימונים, המייצר קובץ בשם נקודת ביקורת העוקב אחר נקודות ביקורת קיימות יחד עם הקודם. מסיבה זו, אין להשתמש מחדש backup_dir לאחסון מחסומים אחרים כדי למנוע התנגשות בשמות.

נכון לעכשיו, התקשרות חוזרת של BackupAndRestore תומכת בעובד יחיד ללא אסטרטגיה, MirroredStrategy ורב-עובדים עם MultiWorkerMirroredStrategy. להלן שתי דוגמאות הן להכשרה רב עובדים והן להכשרת עובדים בודדים.

 # Multi-worker training with MultiWorkerMirroredStrategy.

callbacks = [tf.keras.callbacks.experimental.BackupAndRestore(backup_dir='/tmp/backup')]
with strategy.scope():
  multi_worker_model = build_and_compile_cnn_model()
multi_worker_model.fit(multi_worker_dataset,
                       epochs=3,
                       steps_per_epoch=70,
                       callbacks=callbacks)
 
Epoch 1/3
70/70 [==============================] - 0s 3ms/step - loss: 2.2837 - accuracy: 0.1836
Epoch 2/3
70/70 [==============================] - 0s 3ms/step - loss: 2.2131 - accuracy: 0.4091
Epoch 3/3
70/70 [==============================] - 0s 3ms/step - loss: 2.1310 - accuracy: 0.5485

<tensorflow.python.keras.callbacks.History at 0x7fc5f49a3080>

אם אתה בודק את ספריית ה- backup_dir שציינת ב- BackupAndRestore , ייתכן שתבחין בכמה קבצי מחסום שנוצרו באופן זמני. קבצים אלה נדרשים לשחזור המקרים שאבדו בעבר, והם יוסרו על ידי הספרייה בסוף tf.keras.Model.fit() לאחר יציאה מוצלחת מהאימון שלך.

ראה גם

  1. הדרכה מבוזרת במדריך TensorFlow מספק סקירה של אסטרטגיות ההפצה הזמינות.
  2. דגמים רשמיים , שרבים מהם יכולים להיות מוגדרים להפעלת אסטרטגיות הפצה מרובות.
  3. פרק הביצועים במדריך מספק מידע על אסטרטגיות וכלים אחרים שבהם תוכלו להשתמש בכדי לייעל את הביצועים של דגמי TensorFlow שלכם.