הצג באתר TensorFlow.org | הפעל בגוגל קולאב | צפה במקור ב-GitHub | הורד מחברת |
סקירה כללית
tf.distribute.Strategy
הוא TensorFlow API להפצת הכשרה על פני מספר GPUs, מספר מכונות או TPUs. באמצעות ממשק API זה, אתה יכול להפיץ את הדגמים הקיימים ואת קוד ההדרכה שלך עם שינויים מינימליים בקוד.
tf.distribute.Strategy
תוכננה מתוך מחשבה על מטרות מפתח אלו:
- קל לשימוש ותמיכה במקטעי משתמשים מרובים, כולל חוקרים, מהנדסי למידת מכונה וכו'.
- לספק ביצועים טובים מחוץ לקופסה.
- מעבר קל בין אסטרטגיות.
אתה יכול להפיץ אימון באמצעות tf.distribute.Strategy
עם API ברמה גבוהה כמו Keras Model.fit
, כמו גם לולאות אימון מותאמות אישית (ובאופן כללי, כל חישוב באמצעות TensorFlow).
ב-TensorFlow 2.x, אתה יכול להפעיל את התוכניות שלך בשקיקה, או בגרף באמצעות tf.function
. tf.distribute.Strategy
מתכוונת לתמוך בשני אופני הביצוע הללו, אך פועלת בצורה הטובה ביותר עם tf.function
. מצב להוט מומלץ רק למטרות ניפוי באגים ואינו נתמך עבור tf.distribute.TPUStrategy
. למרות שהדרכה היא המוקד של מדריך זה, ממשק API זה יכול לשמש גם להפצת הערכה וחיזוי בפלטפורמות שונות.
אתה יכול להשתמש ב- tf.distribute.Strategy
עם מעט מאוד שינויים בקוד שלך, מכיוון שהרכיבים הבסיסיים של TensorFlow שונו כדי להיות מודעים לאסטרטגיה. זה כולל משתנים, שכבות, מודלים, מייעלים, מדדים, סיכומים ונקודות ביקורת.
במדריך זה תלמדו על סוגים שונים של אסטרטגיות וכיצד תוכלו להשתמש בהן במצבים שונים. כדי ללמוד כיצד לבצע ניפוי באגים בביצועים, עיין במדריך הביצועים של Optimize TensorFlow GPU .
הגדר את TensorFlow
import tensorflow as tf
סוגי אסטרטגיות
tf.distribute.Strategy
מתכוונת לכסות מספר מקרי שימוש לאורך צירים שונים. חלק מהשילובים הללו נתמכים כעת ואחרים יתווספו בעתיד. חלק מהצירים הללו הם:
- אימון סינכרוני לעומת אסינכרוני: אלו הן שתי דרכים נפוצות להפצת אימון עם מקביליות נתונים. באימון סנכרון, כל העובדים מתאמנים על פרוסות שונות של נתוני קלט בסנכרון, וצבירת מעברי צבע בכל שלב. בהדרכה אסינכרונית, כל העובדים מתאמנים באופן עצמאי על נתוני הקלט ומעדכנים משתנים באופן אסינכרוני. בדרך כלל אימון סנכרון נתמך באמצעות הקטנת הכל ואסינכרון באמצעות ארכיטקטורת שרת פרמטרים.
- פלטפורמת חומרה: ייתכן שתרצה להתאים את האימון שלך למספר GPUs במכונה אחת, או למספר מכונות ברשת (עם 0 או יותר GPUs כל אחד), או ב-Cloud TPUs.
על מנת לתמוך במקרים של שימוש אלה, ל-TensorFlow יש MirroredStrategy
, TPUStrategy
, MultiWorkerMirroredStrategy
, ParameterServerStrategy
, CentralStorageStrategy
, כמו גם אסטרטגיות אחרות זמינות. הסעיף הבא מסביר אילו מהם נתמכים באילו תרחישים ב-TensorFlow. הנה סקירה מהירה:
הדרכה API | MirroredStrategy | TPUStrategy | MultiWorkerMirroredStrategy | CentralStorageStrategy | ParameterServerStrategy |
---|---|---|---|---|---|
Keras Model.fit | נתמך | נתמך | נתמך | תמיכה נסיונית | תמיכה נסיונית |
לולאת אימון מותאמת אישית | נתמך | נתמך | נתמך | תמיכה נסיונית | תמיכה נסיונית |
API של Estimator | תמיכה מוגבלת | אינו נתמך | תמיכה מוגבלת | תמיכה מוגבלת | תמיכה מוגבלת |
אסטרטגיית מראה
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',)
אסטרטגיה של TPUS
tf.distribute.TPUStrategy
מאפשרת לך להפעיל את אימון TensorFlow שלך על יחידות עיבוד Tensor (TPUs) . TPUs הם ASICs המיוחדים של Google שנועדו להאיץ באופן דרמטי את עומסי העבודה של למידת מכונה. הם זמינים ב- Google Colab , ב- TPU Research Cloud וב- Cloud TPU .
במונחים של ארכיטקטורת אימון מבוזר, TPUStrategy
היא אותה MirroredStrategy
- היא מיישמת אימון מבוזר סינכרוני. TPUs מספקים יישום משלהם של פעולות יעילות להפחתת הכל ופעולות קולקטיביות אחרות על פני ליבות 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
עוזר לאתר את ה-TPUs. ב-Colab, אתה לא צריך לציין טיעונים כלשהם.
אם אתה רוצה להשתמש בזה עבור TPUs בענן:
- עליך לציין את השם של משאב ה-TPU שלך בארגומנט
tpu
. - עליך לאתחל את מערכת ה-TPU במפורש בתחילת התוכנית. זה נדרש לפני שניתן להשתמש ב-TPUs לחישוב. אתחול מערכת ה-TPU מוחק גם את זיכרון ה-TPU, לכן חשוב להשלים את השלב הזה תחילה על מנת למנוע אובדן מצב.
אסטרטגיית MultiWorkerMirrored
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:Single-worker MultiWorkerMirroredStrategy with local_devices = ('/device:GPU:0',), communication = CommunicationImplementation.AUTO
ל- MultiWorkerMirroredStrategy
יש שני יישומים לתקשורת חוצת-מכשירים. CommunicationImplementation.RING
מבוסס RPC ותומך הן במעבדים והן במעבדי GPU. CommunicationImplementation.NCCL
משתמש ב-NCCL ומספק ביצועים חדישים במעבדי GPU אך הוא אינו תומך במעבדים. CollectiveCommunication.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:Single-worker MultiWorkerMirroredStrategy with local_devices = ('/device:GPU:0',), communication = CommunicationImplementation.NCCL
אחד ההבדלים העיקריים להפעלת הכשרה מרובה עובדים, בהשוואה לאימון ריבוי GPU, הוא ההגדרה של ריבוי עובדים. משתנה הסביבה 'TF_CONFIG'
הוא הדרך הסטנדרטית ב-TensorFlow לציין את תצורת האשכול לכל עובד שהוא חלק מהאשכול. למידע נוסף בסעיף הגדרת TF_CONFIG במסמך זה.
לפרטים נוספים על MultiWorkerMirroredStrategy
, שקול את המדריכים הבאים:
ParameterServerStrategy
אימון שרת פרמטרים הוא שיטה נפוצה מקבילה לנתונים להגדלת הדרכת מודלים במספר מכונות. אשכול הדרכה לשרת פרמטרים מורכב מעובדים ושרתי פרמטרים. משתנים נוצרים בשרתי פרמטרים והם נקראים ומתעדכנים על ידי העובדים בכל שלב. עיין במדריך ההדרכה של שרת פרמטרים לפרטים.
ב-TensorFlow 2, הכשרת שרת פרמטרים משתמשת בארכיטקטורה מבוססת רכז מרכזי דרך הכיתה tf.distribute.experimental.coordinator.ClusterCoordinator
.
ביישום זה, משימות parameter server
מריצים worker
s שמקשיבים למשימות tf.distribute.Server
. הרכז יוצר משאבים, שולח משימות הדרכה, כותב מחסומים ומטפל בכשלים במשימה.
בתכנות הפועל על המתאם, תשתמש באובייקט ParameterServerStrategy
כדי להגדיר שלב הדרכה ותשתמש ב- ClusterCoordinator
כדי לשלוח שלבי הדרכה לעובדים מרוחקים. הנה הדרך הפשוטה ביותר ליצור אותם:
strategy = tf.distribute.experimental.ParameterServerStrategy(
tf.distribute.cluster_resolver.TFConfigClusterResolver(),
variable_partitioner=variable_partitioner)
coordinator = tf.distribute.experimental.coordinator.ClusterCoordinator(
strategy)
למידע נוסף על ParameterServerStrategy
, בדוק את ההדרכה של שרת פרמטרים עם Keras Model.fit ומדריך לולאת אימון מותאם אישית .
ב-TensorFlow 1, ParameterServerStrategy
זמין רק עם Estimator דרך סמל tf.compat.v1.distribute.experimental.ParameterServerStrategy
.
אסטרטגיית אחסון מרכזית
tf.distribute.experimental.CentralStorageStrategy
גם אימון סינכרוני. משתנים אינם משתקפים, במקום זאת הם ממוקמים על ה-CPU והפעולות משוכפלות על פני כל ה-GPUs המקומיים. אם יש רק 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
שישתמש בכל ה-GPUs וה-CPU הגלויים. עדכון למשתנים בעותקים משוכפלים יצטבר לפני יישום המשתנים.
אסטרטגיות אחרות
בנוסף לאסטרטגיות שלעיל, ישנן שתי אסטרטגיות נוספות שעשויות להיות שימושיות עבור אב טיפוס וניפוי באגים בעת שימוש בממשקי 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
ולהשתמש באסטרטגיה זו להפחתת הדרגות - היא תמיד תחזיר אובייקט אסטרטגיה עליו תוכל לקרוא ל-APIStrategy.reduce
.
# 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 the Default Strategy
strategy = tf.distribute.get_strategy()
with strategy.scope():
# Do something interesting
print(tf.Variable(1.))
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',) MirroredVariable:{ 0: <tf.Variable 'Variable:0' shape=() dtype=float32, numpy=1.0> }
OneDevice Strategy
tf.distribute.OneDeviceStrategy
היא אסטרטגיה להצבת כל המשתנים והחישובים במכשיר שצוין יחיד.
strategy = tf.distribute.OneDeviceStrategy(device="/gpu:0")
אסטרטגיה זו נבדלת מאסטרטגיית ברירת המחדל במספר דרכים. באסטרטגיית ברירת המחדל, לוגיקת המיקום המשתנה נשארת ללא שינוי בהשוואה להפעלת TensorFlow ללא כל אסטרטגיית הפצה. אבל בעת שימוש ב- OneDeviceStrategy
, כל המשתנים שנוצרו בהיקפו ממוקמים במפורש על המכשיר שצוין. יתר על כן, כל פונקציה שנקראת דרך OneDeviceStrategy.run
גם במכשיר שצוין.
קלט שמופץ באמצעות אסטרטגיה זו יאוחזר מראש למכשיר שצוין. באסטרטגיית ברירת המחדל, אין הפצת קלט.
בדומה לאסטרטגיית ברירת המחדל, ניתן להשתמש באסטרטגיה זו גם כדי לבדוק את הקוד שלך לפני המעבר לאסטרטגיות אחרות המופצות למעשה למספר מכשירים/מכונות. זה יפעיל את מנגנון אסטרטגיית ההפצה קצת יותר מאסטרטגיית ברירת המחדל, אך לא במידה המלאה של שימוש, למשל, MirroredStrategy
או TPUStrategy
. אם אתה רוצה קוד שמתנהג כאילו אין אסטרטגיה, השתמש באסטרטגיית ברירת המחדל.
עד כה למדת על אסטרטגיות שונות וכיצד ניתן ליצור אותן. הסעיפים הבאים מציגים את הדרכים השונות שבהן אתה יכול להשתמש בהם כדי להפיץ את האימונים שלך.
השתמש ב-tf.distribute.Strategy עם Keras Model.fit
tf.distribute.Strategy
משולבת ב- tf.keras
, שהיא היישום של TensorFlow של מפרט Keras API . tf.keras
הוא API ברמה גבוהה לבנייה והדרכה של דגמים. על ידי שילוב ב-backend של tf.keras
, זה חלק עבורך להפיץ את ההדרכה שלך שנכתבה במסגרת ההדרכה של Keras באמצעות Model.fit .
הנה מה שאתה צריך לשנות בקוד שלך:
- צור מופע של
tf.distribute.Strategy
המתאימה. - העבר את יצירת המודל, כלי האופטימיזציה והמדדים של Keras בתוך
strategy.scope
.
אסטרטגיות הפצה של TensorFlow תומכות בכל סוגי המודלים של Keras - רצף , פונקציונלי ותת-סיווג.
להלן קטע קוד לעשות זאת עבור דגם Keras פשוט מאוד עם שכבה אחת Dense
:
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',). 2021-10-26 01:27:56.527729: W tensorflow/core/grappler/optimizers/data/auto_shard.cc:695] 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: "TensorDataset/_2" op: "TensorDataset" input: "Placeholder/_0" input: "Placeholder/_1" attr { key: "Toutput_types" value { list { type: DT_FLOAT type: DT_FLOAT } } } attr { key: "output_shapes" value { list { shape { dim { size: 1 } } shape { dim { size: 1 } } } } } 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: 2.2552 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.9968 2021-10-26 01:27:59.372113: W tensorflow/core/grappler/optimizers/data/auto_shard.cc:695] 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: "TensorDataset/_2" op: "TensorDataset" input: "Placeholder/_0" input: "Placeholder/_1" attr { key: "Toutput_types" value { list { type: DT_FLOAT type: DT_FLOAT } } } attr { key: "output_shapes" value { list { shape { dim { size: 1 } } shape { dim { size: 1 } } } } } 10/10 [==============================] - 1s 2ms/step - loss: 0.6190 0.6190494298934937
כאן tf.data.Dataset
מספק את ההדרכה והקלט. אתה יכול גם להשתמש במערכים NumPy:
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 2021-10-26 01:28:00.609977: W tensorflow/core/grappler/optimizers/data/auto_shard.cc:695] AUTO sharding policy will apply DATA sharding policy as it failed to apply FILE sharding policy because of the following reason: Did not find a shardable source, walked to a node which is not a dataset: name: "FlatMapDataset/_9" op: "FlatMapDataset" input: "PrefetchDataset/_8" attr { key: "Targuments" value { list { } } } attr { key: "f" value { func { name: "__inference_Dataset_flat_map_slice_batch_indices_997" } } } attr { key: "output_shapes" value { list { shape { dim { size: 10 } } } } } attr { key: "output_types" value { list { type: DT_INT64 } } } . Consider either turning off auto-sharding or switching the auto_shard_policy to DATA to shard this dataset. You can do this by creating a new `tf.data.Options()` object then setting `options.experimental_distribute.auto_shard_policy = AutoShardPolicy.DATA` before applying the options object to the dataset via `dataset.with_options(options)`. 10/10 [==============================] - 1s 2ms/step - loss: 0.4406 Epoch 2/2 10/10 [==============================] - 0s 2ms/step - loss: 0.1947 <keras.callbacks.History at 0x7fb81813d2d0>
בשני המקרים - עם Dataset
או NumPy - כל אצווה של הקלט הנתון מחולקת באופן שווה בין העותקים המרובים. לדוגמה, אם אתה משתמש ב- MirroredStrategy
עם 2 GPUs, כל אצווה בגודל 10 תחולק בין 2 GPUs, כאשר כל אחד יקבל 5 דוגמאות קלט בכל שלב. לאחר מכן כל תקופה תתאמן מהר יותר ככל שתוסיף עוד GPUs. בדרך כלל, תרצה להגדיל את גודל האצווה שלך ככל שתוסיף עוד מאיצים, כדי לעשות שימוש יעיל בכוח המחשוב הנוסף. תצטרך גם לכוון מחדש את קצב הלמידה שלך, בהתאם לדגם. אתה יכול להשתמש ב- strategy.num_replicas_in_sync
כדי לקבל את מספר ההעתקים.
# Compute a global batch size using a 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 |
---|---|---|---|---|---|
Keras Model.fit | נתמך | נתמך | נתמך | תמיכה נסיונית | תמיכה נסיונית |
דוגמאות והדרכות
להלן רשימה של מדריכים ודוגמאות הממחישות את האינטגרציה שלעיל מקצה לקצה עם Keras Model.fit
:
- הדרכה : אימון עם
Model.fit
ו-MirroredStrategy
. - הדרכה : אימון עם
Model.fit
ו-MultiWorkerMirroredStrategy
. - מדריך : מכיל דוגמה לשימוש ב-
Model.fit
וב-TPUStrategy
. - הדרכה : אימון שרת פרמטרים עם
Model.fit
ו-ParameterServerStrategy
. - מדריך : כוונון עדין של BERT למשימות רבות ממבחן ה-GLUE עם
Model.fit
ו-TPUStrategy
. - מאגר TensorFlow Model Garden המכיל אוספים של מודלים חדישים המיושמים באמצעות אסטרטגיות שונות.
השתמש ב-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)
2021-10-26 01:28:01.831942: W tensorflow/core/grappler/optimizers/data/auto_shard.cc:695] 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: "TensorDataset/_2" op: "TensorDataset" input: "Placeholder/_0" input: "Placeholder/_1" attr { key: "Toutput_types" value { list { type: DT_FLOAT type: DT_FLOAT } } } attr { key: "output_shapes" value { list { shape { dim { size: 1 } } shape { dim { size: 1 } } } } }
לאחר מכן, הגדירו שלב אחד באימון. השתמש tf.GradientTape
כדי לחשב מעברי צבע ואופטימיזציה כדי להחיל את ההדרגות כדי לעדכן את המשתנים של המודל שלך. כדי להפיץ את שלב ההדרכה הזה, הכניסו אותו לפונקציה train_step
והעבירו אותו ל- tf.distribute.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
. זה חשוב כי מאוחר יותר לאחר חישוב ההדרגות על כל העתק, הם מצטברים על פני ההעתקים על ידי סיכומם . - השתמשת גם בממשק 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.18686396, shape=(), dtype=float32) tf.Tensor(0.18628375, shape=(), dtype=float32) tf.Tensor(0.18570684, shape=(), dtype=float32) tf.Tensor(0.18513316, shape=(), dtype=float32) tf.Tensor(0.1845627, shape=(), dtype=float32) tf.Tensor(0.18399543, shape=(), dtype=float32) tf.Tensor(0.18343134, shape=(), dtype=float32) tf.Tensor(0.18287037, shape=(), dtype=float32) tf.Tensor(0.18231256, shape=(), dtype=float32) tf.Tensor(0.18175781, shape=(), dtype=float32) tf.Tensor(0.18120615, shape=(), dtype=float32) tf.Tensor(0.18065754, shape=(), dtype=float32) tf.Tensor(0.18011193, shape=(), dtype=float32) tf.Tensor(0.17956935, shape=(), dtype=float32) tf.Tensor(0.17902976, shape=(), dtype=float32) tf.Tensor(0.17849308, shape=(), dtype=float32) tf.Tensor(0.17795937, shape=(), dtype=float32) tf.Tensor(0.17742859, shape=(), dtype=float32) tf.Tensor(0.17690066, shape=(), dtype=float32) tf.Tensor(0.17637561, shape=(), dtype=float32)
בדוגמה למעלה, עברת על ה- dist_dataset
כדי לספק קלט לאימון שלך. אתה גם מסופק עם ערכת הנתונים tf.distribute.Strategy.make_experimental_numpy_dataset
כדי לתמוך בכניסות NumPy. אתה יכול להשתמש ב-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.17585339, shape=(), dtype=float32) tf.Tensor(0.17533402, shape=(), dtype=float32) tf.Tensor(0.17481743, shape=(), dtype=float32) tf.Tensor(0.17430364, shape=(), dtype=float32) tf.Tensor(0.17379259, shape=(), dtype=float32) tf.Tensor(0.17328428, shape=(), dtype=float32) tf.Tensor(0.17277871, shape=(), dtype=float32) tf.Tensor(0.17227581, shape=(), dtype=float32) tf.Tensor(0.17177561, shape=(), dtype=float32) tf.Tensor(0.17127804, shape=(), dtype=float32)
זה מכסה את המקרה הפשוט ביותר של שימוש ב- tf.distribute.Strategy
API כדי להפיץ לולאות אימון מותאמות אישית.
מה נתמך עכשיו?
הדרכה API | MirroredStrategy | TPUStrategy | MultiWorkerMirroredStrategy | ParameterServerStrategy | CentralStorageStrategy |
---|---|---|---|---|---|
לולאת אימון מותאמת אישית | נתמך | נתמך | נתמך | תמיכה נסיונית | תמיכה נסיונית |
דוגמאות והדרכות
הנה כמה דוגמאות לשימוש באסטרטגיות הפצה עם לולאות אימון מותאמות אישית:
- הדרכה : אימון עם לולאת אימון מותאמת אישית ו-
MirroredStrategy
. - הדרכה : אימון עם לולאת אימון מותאמת אישית ו-
MultiWorkerMirroredStrategy
. - מדריך : מכיל דוגמה ללולאת אימון מותאמת אישית עם
TPUStrategy
. - מדריך : אימון שרת פרמטרים עם לולאת אימון מותאמת אישית ו-
ParameterServerStrategy
. - מאגר TensorFlow Model Garden המכיל אוספים של מודלים חדישים המיושמים באמצעות אסטרטגיות שונות.
נושאים אחרים
חלק זה מכסה כמה נושאים שרלוונטיים למקרי שימוש מרובים.
הגדרת משתנה הסביבה TF_CONFIG
להכשרה מרובה עובדים, כפי שהוזכר קודם לכן, עליך להגדיר את משתנה הסביבה 'TF_CONFIG'
עבור כל בינארי הפועל באשכול שלך. משתנה הסביבה 'TF_CONFIG'
הוא מחרוזת JSON המציינת אילו משימות מהוות אשכול, הכתובות שלהן ותפקידה של כל משימה באשכול. ה- tensorflow/ecosystem
מספקת תבנית '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"
ב"אשכול "cluster"
יחד עם המארחים והיציאות שלהם. חלק ה"משימה "task"
מציין את התפקיד של המשימה הנוכחית ב"אשכול "cluster"
- עובד 1
(העובד השני). תפקידים תקפים באשכול הם "chief"
, "worker"
, "ps"
"evaluator"
. לא אמורה להיות עבודת "ps"
אלא בעת שימוש ב- tf.distribute.experimental.ParameterServerStrategy
.
מה הלאה?
tf.distribute.Strategy
נמצאת בפיתוח פעיל. נסה את זה וספק את המשוב שלך באמצעות בעיות GitHub .