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

אימונים מבוזרים עם TensorFlow

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

סקירה כללית

tf.distribute.Strategy הוא ממשק API של TensorFlow להפצת אימונים על גבי מספר GPUs, מספר מכונות או TPU. באמצעות ממשק API זה תוכלו להפיץ את הדגמים וקוד האימונים הקיימים שלכם עם שינויי קוד מינימליים.

tf.distribute.Strategy תוכנן עם מטרות מפתח אלה בחשבון:

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

ניתן להשתמש ב- tf.distribute.Strategy עם ממשק API ברמה גבוהה כמו Keras , וניתן להשתמש בו גם להפצת לולאות אימון מותאמות אישית (ובכלל, כל חישוב באמצעות TensorFlow).

ב- TensorFlow 2.x, אתה יכול לבצע את התוכניות שלך בשקיקה, או בגרף באמצעות tf.function . tf.distribute.Strategy מתכוונת לתמוך בשני מצבי הביצוע הללו, אך עובדת בצורה הטובה ביותר עם tf.function . מצב להוט מומלץ רק לצורך איתור באגים ואינו נתמך עבור TPUStrategy . למרות שאימון הוא המוקד של מדריך זה, ניתן להשתמש ב- API זה גם להפצת הערכה וחיזוי בפלטפורמות שונות.

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

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

# Import TensorFlow
import tensorflow as tf

סוגי אסטרטגיות

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

  • אימון סינכרוני לעומת אסינכרוני: אלו שתי דרכים נפוצות להפצת אימונים במקביל לנתונים. בהדרכת סינכרון, כל העובדים מתאמנים על פרוסות שונות של נתוני קלט מסונכרנים, ומצטברים שיפועים בכל שלב. בהדרכת אסינכרון, כל העובדים מתאמנים באופן עצמאי על נתוני הקלט ומעדכנים משתנים באופן אסינכרוני. בדרך כלל אימון סנכרון נתמך באמצעות כל צמצום ואסינכרון באמצעות ארכיטקטורת שרת פרמטרים.
  • פלטפורמת חומרה: ייתכן שתרצה להגדיל את האימונים שלך למספר GPUs במחשב אחד, או למספר מכונות ברשת (עם 0 או יותר GPUs כל אחת), או ב- TPUs של ענן.

על מנת לתמוך במקרי שימוש אלה, קיימות שש אסטרטגיות. החלק הבא מסביר אילו מבין אלה נתמכים באילו תרחישים ב- TF. הנה סקירה מהירה:

ממשק API להכשרה MirroredStrategy TPUStrategy MultiWorkerMirroredStrategy CentralStorageStrategy ParameterServerStrategy
ממשק API של קרס נתמך נתמך תמיכה ניסיונית תמיכה ניסיונית פוסט מתוכנן 2.3 נתמך
לולאת אימונים בהתאמה אישית נתמך נתמך תמיכה ניסיונית תמיכה ניסיונית פוסט מתוכנן נתמך 2.3
ממשק API של אומדן תמיכה מוגבלת אינו נתמך תמיכה מוגבלת תמיכה מוגבלת תמיכה מוגבלת

MirroredStrategy

tf.distribute.MirroredStrategy תומך באימונים מבוזרים סינכרוניים במספר GPUs במחשב אחד. זה יוצר העתק אחד לכל מכשיר GPU. כל משתנה במודל משתקף בכל העתקים. יחד, המשתנים הללו יוצרים משתנה מושגי אחד הנקרא MirroredVariable . משתנים אלה נשמרים מסונכרנים זה עם זה על ידי החלת עדכונים זהים.

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

הנה הדרך הפשוטה ביותר ליצור MirroredStrategy :

mirrored_strategy = tf.distribute.MirroredStrategy()
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)

פעולה זו תיצור מופע של MirroredStrategy אשר ישתמש בכל GPUs הגלויים ל- TensorFlow, וישתמש ב- NCCL כתקשורת בין מכשירים.

אם ברצונך להשתמש רק בחלק מה- GPUs במחשב שלך, תוכל לעשות זאת כך:

mirrored_strategy = tf.distribute.MirroredStrategy(devices=["/gpu:0", "/gpu:1"])
WARNING:tensorflow:Some requested devices in `tf.distribute.Strategy` are not visible to TensorFlow: /job:localhost/replica:0/task:0/device:GPU:1,/job:localhost/replica:0/task:0/device:GPU:0
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0', '/job:localhost/replica:0/task:0/device:GPU:1')

אם ברצונך לבטל את התקשורת בין מכשירים, תוכל לעשות זאת באמצעות הארגומנט cross_device_ops ידי אספקת מופע של tf.distribute.CrossDeviceOps . נכון לעכשיו, tf.distribute.HierarchicalCopyAllReduce ו- tf.distribute.ReductionToOneDevice הן שתי אפשרויות אחרות מלבד tf.distribute.NcclAllReduce שהיא ברירת המחדל.

mirrored_strategy = tf.distribute.MirroredStrategy(
    cross_device_ops=tf.distribute.HierarchicalCopyAllReduce())
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)

TPUStrategy

tf.distribute.TPUStrategy מאפשר לך להריץ את הכשרת TensorFlow שלך על יחידות עיבוד טנזורים (TPU). TPUs הם ה- ASIC המיוחדים של גוגל שנועדו להאיץ דרמטית את עומסי העבודה של למידת מכונה. הם זמינים ב- Google Colab, בענן המחקר TensorFlow וב- TPU בענן .

מבחינת ארכיטקטורת האימונים TPUStrategy , TPUStrategy היא אותה MirroredStrategy - היא מיישמת אימונים מבוזרים סינכרוניים. TPUs מספקים יישום משלהם של פעולות קולקטיביות יעילות להפחתה ולכל TPUStrategy פני מספר ליבות TPU, המשמשות ב- TPUStrategy .

כך תוכל TPUStrategy :

cluster_resolver = tf.distribute.cluster_resolver.TPUClusterResolver(
    tpu=tpu_address)
tf.config.experimental_connect_to_cluster(cluster_resolver)
tf.tpu.experimental.initialize_tpu_system(cluster_resolver)
tpu_strategy = tf.distribute.TPUStrategy(cluster_resolver)

מופע TPUClusterResolver מסייע באיתור ה- TPU. בקולאב אינך צריך לציין טיעונים כלשהם.

אם אתה רוצה להשתמש בזה עבור ענני TPU:

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

MultiWorkerMirroredStrategy

tf.distribute.MultiWorkerMirroredStrategy דומה מאוד ל- MirroredStrategy . הוא מיישם הכשרה מבוזרת סינכרונית על פני מספר עובדים, כל אחד עם GPUs בעל פוטנציאל מרובה. בדומה ל- tf.distribute.MirroredStrategy , היא יוצרת עותקים של כל המשתנים במודל בכל מכשיר בכל העובדים.

הנה הדרך הפשוטה ביותר ליצור MultiWorkerMirroredStrategy :

strategy = tf.distribute.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 = CommunicationImplementation.AUTO

MultiWorkerMirroredStrategy יש שתי יישומים לתקשורת בין מכשירים. CommunicationImplementation.RING מבוסס RPC ותומך הן במעבד והן ב- GPU. CommunicationImplementation.NCCL משתמש ב- NCCL של Nvidia ומספק ביצועים חדישים ב- GPU, אך הוא אינו תומך במעבד. CollectiveCommunication.AUTO תקשורת. AUTO מגדירה את הבחירה בפני Tensorflow. אתה יכול לציין אותם באופן הבא:

communication_options = tf.distribute.experimental.CommunicationOptions(
    implementation=tf.distribute.experimental.CommunicationImplementation.NCCL)
strategy = tf.distribute.MultiWorkerMirroredStrategy(
    communication_options=communication_options)
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 = CommunicationImplementation.NCCL

אחד ההבדלים העיקריים להנחיית הכשרה מרובת עובדים, בהשוואה להכשרה מרובת GPU, הוא ההתקנה מרובת העובדים. משתנה הסביבה TF_CONFIG הוא הדרך הסטנדרטית ב- TensorFlow לציין את תצורת האשכול לכל עובד שהוא חלק מהאשכול. למידע נוסף על הגדרת TF_CONFIG .

ParameterServerStrategy

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

הכשרת שרתים פרמטרים של TensorFlow 2 משתמשת בארכיטקטורה מבוססת רכז מרכזי באמצעות המחלקה tf.distribute.experimental.coordinator.ClusterCoordinator .

ביישום זה משימות parameter server worker parameter server מריצות את tf.distribute.Server למשימות tf.distribute.Server . הרכז יוצר משאבים, משגר משימות אימונים, כותב מחסומים ומתמודד עם כשלים במשימה.

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

strategy = tf.distribute.experimental.ParameterServerStrategy(
    tf.distribute.cluster_resolver.TFConfigClusterResolver(),
    variable_partitioner=variable_partitioner)
coordinator = tf.distribute.experimental.coordinator.ClusterCoordinator(
    strategy)

שים לב שיהיה עליך להגדיר את תצורת משתנה הסביבה TF_CONFIG אם אתה משתמש ב- TFConfigClusterResolver . זה דומה ל- TF_CONFIG ב- MultiWorkerMirroredStrategy אך יש אזהרות נוספות.

ב- TF 1, ParameterServerStrategy זמין רק עם אומדן באמצעות סמל tf.compat.v1.distribute.experimental.ParameterServerStrategy .

CentralStorageStrategy

tf.distribute.experimental.CentralStorageStrategy עושה גם אימונים סינכרוניים. המשתנים אינם משתקפים, במקום זאת הם ממוקמים על המעבד והפעולות משוכפלות בכל המעבדים המקומיים. אם יש רק GPU אחד, כל המשתנים והפעולות ימוקמו על אותו GPU.

צור מופע של CentralStorageStrategy ידי:

central_storage_strategy = tf.distribute.experimental.CentralStorageStrategy()
INFO:tensorflow:ParameterServerStrategy (CentralStorageStrategy if you are using a single machine) with compute_devices = ['/job:localhost/replica:0/task:0/device:GPU:0'], variable_device = '/job:localhost/replica:0/task:0/device:GPU:0'

זה ייצור מופע של CentralStorageStrategy שישתמש בכל המעבדים והמעבד הגלויים לעין. עדכון למשתנים על עותקים משוכפלים לפני שיוחל על משתנים.

אסטרטגיות אחרות

בנוסף לאסטרטגיות שלעיל, ישנן שתי אסטרטגיות אחרות שעשויות להיות שימושיות עבור אב טיפוס tf.distribute באגים בעת שימוש בממשקי API של tf.distribute .

אסטרטגיית ברירת מחדל

אסטרטגיית ברירת מחדל היא אסטרטגיית הפצה אשר קיימת כאשר אין אסטרטגיית הפצה מפורשת בתחום. הוא מיישם את ממשק tf.distribute.Strategy אך הוא מעבר דרך ואינו מספק הפצה בפועל. למשל, strategy.run(fn) פשוט יקרא fn . קוד שנכתב באמצעות אסטרטגיה זו צריך להתנהג בדיוק כמו קוד שנכתב ללא שום אסטרטגיה. אתה יכול לחשוב על זה כעל אסטרטגיה "לא-אופ".

אסטרטגיית ברירת מחדל היא יחיד - ואי אפשר ליצור יותר מקרים שלו. ניתן להשיג באמצעות tf.distribute.get_strategy() מחוץ לכל תחום אסטרטגיה מפורשת (אותו ממשק API שניתן להשתמש בו כדי להכניס את האסטרטגיה הנוכחית לתחום של אסטרטגיה מפורשת).

default_strategy = tf.distribute.get_strategy()

אסטרטגיה זו משרתת שתי מטרות עיקריות:

  • זה מאפשר לכתוב קוד ספריה מודע להפצה ללא תנאי. לדוגמא, ב- tf.optimizer s יכול להשתמש ב- tf.distribute.get_strategy() ולהשתמש באסטרטגיה זו להפחתת שיפועים - היא תמיד תחזיר אובייקט אסטרטגי עליו נוכל לקרוא ה- API של להפחית.
# In optimizer or other library code
# Get currently active strategy
strategy = tf.distribute.get_strategy()
strategy.reduce("SUM", 1., axis=None)  # reduce some values
1.0
  • בדומה לקוד הספרייה, ניתן להשתמש בו כדי לכתוב תוכניות של משתמשי קצה לעבודה עם וללא אסטרטגיית הפצה, מבלי לדרוש לוגיקה מותנית. קטע קוד לדוגמה הממחיש זאת:
if tf.config.list_physical_devices('gpu'):
  strategy = tf.distribute.MirroredStrategy()
else:  # use default strategy
  strategy = tf.distribute.get_strategy() 

with strategy.scope():
  # do something interesting
  print(tf.Variable(1.))
<tf.Variable 'Variable:0' shape=() dtype=float32, numpy=1.0>

OneDeviceStrategy

tf.distribute.OneDeviceStrategy היא אסטרטגיה למקם את כל המשתנים והחישוב על מכשיר אחד שצוין.

strategy = tf.distribute.OneDeviceStrategy(device="/gpu:0")

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

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

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

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

שימוש ב- tf.distribute.Strategy עם tf.keras.Model.fit

tf.distribute.Strategy משולב ב- tf.keras המהווה את היישום של TensorFlow את מפרט ה- Keras API . tf.keras הוא ממשק API ברמה גבוהה לבניית והכשרת דגמים. על ידי tf.keras backend של tf.keras , הפכנו אתכם לחלק בצורה חלקה את האימונים שלכם שנכתבו במסגרת האימונים של model.fit באמצעות model.fit .

הנה מה שאתה צריך לשנות בקוד שלך:

  1. צור מופע של tf.distribute.Strategy המתאים.
  2. העבר את יצירת מודל Keras, האופטימיזציה והמדדים בתוך strategy.scope .

אנו תומכים בכל סוגי הדגמים של Keras - רציפים, פונקציונליים ומסווגים פחות.

הנה קטע קוד לעשות זאת עבור מודל קרס פשוט מאוד עם שכבה צפופה אחת:

mirrored_strategy = tf.distribute.MirroredStrategy()

with mirrored_strategy.scope():
  model = tf.keras.Sequential([tf.keras.layers.Dense(1, input_shape=(1,))])

model.compile(loss='mse', optimizer='sgd')
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU: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',).

דוגמה זו משתמשת ב- MirroredStrategy כדי שתוכל להריץ זאת במחשב עם מספר GPUs. strategy.scope() מציין בפני Keras באיזו אסטרטגיה להשתמש להפצת האימונים. יצירת מודלים / אופטימיזציה / מדדים בתוך היקף זה מאפשרת לנו ליצור משתנים מבוזרים במקום משתנים רגילים. לאחר הגדרת זה, אתה יכול להתאים את המודל שלך כמו שאתה עושה בדרך כלל. MirroredStrategy דואג לשכפל את אימוני המודל ב- GPUs הזמינים, לצבור שיפועים ועוד.

dataset = tf.data.Dataset.from_tensors(([1.], [1.])).repeat(100).batch(10)
model.fit(dataset, epochs=2)
model.evaluate(dataset)
Epoch 1/2
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',).
10/10 [==============================] - 3s 2ms/step - loss: 0.9810
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',).
Epoch 2/2
10/10 [==============================] - 0s 2ms/step - loss: 0.4336
10/10 [==============================] - 1s 2ms/step - loss: 0.2299

0.22988776862621307

כאןtf.data.Dataset מספק את קלט ההדרכהtf.data.Dataset . אתה יכול גם להשתמש במערכים קהים:

import numpy as np
inputs, targets = np.ones((100, 1)), np.ones((100, 1))
model.fit(inputs, targets, epochs=2, batch_size=10)
Epoch 1/2
10/10 [==============================] - 1s 2ms/step - loss: 0.1636
Epoch 2/2
10/10 [==============================] - 0s 2ms/step - loss: 0.0723

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

בשני המקרים (מערך נתונים או מטומטם), כל אצווה של הקלט הנתון מחולקת באופן שווה בין מספר ההעתקים. לדוגמא, אם משתמשים ב- MirroredStrategy עם 2 GPUs, כל אצווה בגודל 10 תחולק בין 2 GPUs, כאשר כל אחת תקבל 5 דוגמאות קלט בכל שלב. לאחר מכן, כל תקופה תתאמן מהר ככל שתוסיף עוד GPUs. בדרך כלל, תרצה להגדיל את גודל האצווה שלך ככל שתוסיף מאיצים נוספים בכדי להשתמש באפקטיביות בכוח המחשוב הנוסף. יהיה עליך לכוונן מחדש את קצב הלמידה שלך, תלוי במודל. אתה יכול להשתמש ב- strategy.num_replicas_in_sync כדי להשיג את מספר העותקים המשוכפלים.

# Compute global batch size using number of replicas.
BATCH_SIZE_PER_REPLICA = 5
global_batch_size = (BATCH_SIZE_PER_REPLICA *
                     mirrored_strategy.num_replicas_in_sync)
dataset = tf.data.Dataset.from_tensors(([1.], [1.])).repeat(100)
dataset = dataset.batch(global_batch_size)

LEARNING_RATES_BY_BATCH_SIZE = {5: 0.1, 10: 0.15}
learning_rate = LEARNING_RATES_BY_BATCH_SIZE[global_batch_size]

מה נתמך עכשיו?

ממשק API להכשרה MirroredStrategy TPUStrategy MultiWorkerMirroredStrategy ParameterServerStrategy CentralStorageStrategy
ממשקי API של Keras נתמך נתמך תמיכה ניסיונית תמיכה ניסיונית תמיכה ניסיונית

דוגמאות והדרכות

הנה רשימה של מדריכים ודוגמאות הממחישות את האינטגרציה שלעיל מקצה לקצה עם Keras:

  1. הדרכה להכשרת MNIST באמצעות MirroredStrategy .
  2. הדרכה להכשרת MNIST באמצעות MultiWorkerMirroredStrategy .
  3. מדריך להכשרת MNIST באמצעות TPUStrategy .
  4. הדרכה להכשרת שרתים פרמטרים ב- TensorFlow 2 עם ParameterServerStrategy .
  5. מאגר הגן TensorFlow מודל המכיל אוספים של מודלים חדישים המיושמים באמצעות אסטרטגיות שונות.

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

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

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

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

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

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

with mirrored_strategy.scope():
  model = tf.keras.Sequential([tf.keras.layers.Dense(1, input_shape=(1,))])
  optimizer = tf.keras.optimizers.SGD()

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

dataset = tf.data.Dataset.from_tensors(([1.], [1.])).repeat(100).batch(
    global_batch_size)
dist_dataset = mirrored_strategy.experimental_distribute_dataset(dataset)

לאחר מכן, הגדירו שלב אחד של האימון. השתמש ב-tf.GradientTape לחישוב שיפועים ובאופטימיזציה כדי ליישם את הדרגתיות הללו כדי לעדכן את המשתנים של המודל שלנו. כדי להפיץ את שלב האימון הזה, train_step אותו לפונקציה train_step אותו ל- tf.distrbute.Strategy.run יחד עם קלטי הנתונים שקיבלת ממערך dist_dataset שנוצר לפני:

loss_object = tf.keras.losses.BinaryCrossentropy(
  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)

def train_step(inputs):
  features, labels = inputs

  with tf.GradientTape() as tape:
    predictions = model(features, training=True)
    loss = compute_loss(labels, predictions)

  gradients = tape.gradient(loss, model.trainable_variables)
  optimizer.apply_gradients(zip(gradients, model.trainable_variables))
  return loss

@tf.function
def distributed_train_step(dist_inputs):
  per_replica_losses = mirrored_strategy.run(train_step, args=(dist_inputs,))
  return mirrored_strategy.reduce(tf.distribute.ReduceOp.SUM, per_replica_losses,
                         axis=None)

כמה דברים אחרים שיש לציין בקוד לעיל:

  1. הוא השתמש ב- tf.nn.compute_average_loss כדי לחשב את ההפסד. tf.nn.compute_average_loss מסכם את ההפסד לכל דוגמה ומחלק את הסכום ב- global_batch_size. זה חשוב מכיוון שמאוחר יותר לאחר חישוב הדרגתיות על כל העתק, הם נצברים על פני העתקים על ידי סיכומם .
  2. הוא השתמש tf.distribute.Strategy.reduce API של tf.distribute.Strategy.reduce כדי לצבור את התוצאות שהוחזרו על ידי tf.distribute.Strategy.run . tf.distribute.Strategy.run מחזיר תוצאות מכל עותק מקומי באסטרטגיה, וישנן דרכים רבות לצרוך תוצאה זו. אתה יכול reduce אותם כדי לקבל ערך מצטבר. ניתן גם לבצע tf.distribute.Strategy.experimental_local_results כדי לקבל את רשימת הערכים הכלולים בתוצאה, אחד לכל עותק משוכפל.
  3. כאשר apply_gradients במסגרת אסטרטגיית הפצה, ההתנהגות שלה משתנה. באופן ספציפי, לפני החלת שיפועים בכל מופע מקביל במהלך אימון סינכרוני, היא מבצעת סכום כולל של מעתקים.

לבסוף, לאחר שהגדרת את שלב האימון, אנו יכולים לחזור על dist_dataset ולהריץ את האימון בלולאה:

for dist_inputs in dist_dataset:
  print(distributed_train_step(dist_inputs))
tf.Tensor(0.88850546, shape=(), dtype=float32)
tf.Tensor(0.8815902, shape=(), dtype=float32)
tf.Tensor(0.87474185, shape=(), dtype=float32)
tf.Tensor(0.8679599, shape=(), dtype=float32)
tf.Tensor(0.86124384, shape=(), dtype=float32)
tf.Tensor(0.8545932, shape=(), dtype=float32)
tf.Tensor(0.8480073, shape=(), dtype=float32)
tf.Tensor(0.8414857, shape=(), dtype=float32)
tf.Tensor(0.8350279, shape=(), dtype=float32)
tf.Tensor(0.8286335, shape=(), dtype=float32)
tf.Tensor(0.8223018, shape=(), dtype=float32)
tf.Tensor(0.81603223, shape=(), dtype=float32)
tf.Tensor(0.8098244, shape=(), dtype=float32)
tf.Tensor(0.8036777, shape=(), dtype=float32)
tf.Tensor(0.7975916, shape=(), dtype=float32)
tf.Tensor(0.79156566, shape=(), dtype=float32)
tf.Tensor(0.78559923, shape=(), dtype=float32)
tf.Tensor(0.77969193, shape=(), dtype=float32)
tf.Tensor(0.773843, shape=(), dtype=float32)
tf.Tensor(0.7680521, shape=(), dtype=float32)

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

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

iterator = iter(dist_dataset)
for _ in range(10):
  print(distributed_train_step(next(iterator)))
tf.Tensor(0.7623187, shape=(), dtype=float32)
tf.Tensor(0.7566423, shape=(), dtype=float32)
tf.Tensor(0.7510221, shape=(), dtype=float32)
tf.Tensor(0.7454578, shape=(), dtype=float32)
tf.Tensor(0.739949, shape=(), dtype=float32)
tf.Tensor(0.7344949, shape=(), dtype=float32)
tf.Tensor(0.72909516, shape=(), dtype=float32)
tf.Tensor(0.7237492, shape=(), dtype=float32)
tf.Tensor(0.7184567, shape=(), dtype=float32)
tf.Tensor(0.7132167, shape=(), dtype=float32)

זה מכסה את המקרה הפשוט ביותר של שימוש ב- tf.distribute.Strategy API להפצת לולאות אימון מותאמות אישית.

מה נתמך עכשיו?

ממשק API להכשרה MirroredStrategy TPUStrategy MultiWorkerMirroredStrategy ParameterServerStrategy CentralStorageStrategy
לולאת אימונים בהתאמה אישית נתמך נתמך תמיכה ניסיונית תמיכה ניסיונית תמיכה ניסיונית

דוגמאות והדרכות

להלן מספר דוגמאות לשימוש באסטרטגיית הפצה עם לולאות אימון מותאמות אישית:

  1. הדרכה להכשרת MNIST באמצעות MirroredStrategy .
  2. מדריך להכשרת MNIST באמצעות TPUStrategy .
  3. מאגר גן TensorFlow מודל המכיל אוספים של מודלים חדישים המיושמים באמצעות אסטרטגיות שונות.

נושאים אחרים

חלק זה מכסה כמה נושאים הרלוונטיים למקרי שימוש מרובים.

הגדרת משתנה סביבה TF_CONFIG

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

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

דוגמה אחת ל- TF_CONFIG היא:

os.environ["TF_CONFIG"] = json.dumps({
    "cluster": {
        "worker": ["host1:port", "host2:port", "host3:port"],
        "ps": ["host4:port", "host5:port"]
    },
   "task": {"type": "worker", "index": 1}
})

TF_CONFIG זה מציין כי ישנם שלושה עובדים ושתי משימות PS באשכול יחד עם המארחים TF_CONFIG שלהם. החלק "משימה" מציין כי תפקיד המשימה הנוכחית באשכול, עובד 1 (העובד השני). תפקידים תקפים באשכול הם "ראשי", "עובד", "נ.ב." ו"מעריך ". לא אמורה להיות עבודת "ps" למעט בעת שימוש ב- tf.distribute.experimental.ParameterServerStrategy .

מה הלאה?

tf.distribute.Strategy נמצא בפיתוח פעיל. נסה זאת וספק את המשוב שלך באמצעות בעיות GitHub .