![]() | ![]() | ![]() | ![]() |
סקירה כללית
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
.
הנה מה שאתה צריך לשנות בקוד שלך:
- צור מופע של
tf.distribute.Strategy
המתאים. - העבר את יצירת מודל 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:
- הדרכה להכשרת MNIST באמצעות
MirroredStrategy
. - הדרכה להכשרת MNIST באמצעות
MultiWorkerMirroredStrategy
. - מדריך להכשרת MNIST באמצעות
TPUStrategy
. - הדרכה להכשרת שרתים פרמטרים ב- TensorFlow 2 עם
ParameterServerStrategy
. - מאגר הגן 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)
כמה דברים אחרים שיש לציין בקוד לעיל:
- הוא השתמש ב-
tf.nn.compute_average_loss
כדי לחשב את ההפסד.tf.nn.compute_average_loss
מסכם את ההפסד לכל דוגמה ומחלק את הסכום ב- global_batch_size. זה חשוב מכיוון שמאוחר יותר לאחר חישוב הדרגתיות על כל העתק, הם נצברים על פני העתקים על ידי סיכומם . - הוא השתמש
tf.distribute.Strategy.reduce
API שלtf.distribute.Strategy.reduce
כדי לצבור את התוצאות שהוחזרו על ידיtf.distribute.Strategy.run
.tf.distribute.Strategy.run
מחזיר תוצאות מכל עותק מקומי באסטרטגיה, וישנן דרכים רבות לצרוך תוצאה זו. אתה יכולreduce
אותם כדי לקבל ערך מצטבר. ניתן גם לבצעtf.distribute.Strategy.experimental_local_results
כדי לקבל את רשימת הערכים הכלולים בתוצאה, אחד לכל עותק משוכפל. - כאשר
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 |
---|---|---|---|---|---|
לולאת אימונים בהתאמה אישית | נתמך | נתמך | תמיכה ניסיונית | תמיכה ניסיונית | תמיכה ניסיונית |
דוגמאות והדרכות
להלן מספר דוגמאות לשימוש באסטרטגיית הפצה עם לולאות אימון מותאמות אישית:
- הדרכה להכשרת MNIST באמצעות
MirroredStrategy
. - מדריך להכשרת MNIST באמצעות
TPUStrategy
. - מאגר גן 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 .