ترجمت واجهة Cloud Translation API‏ هذه الصفحة.
Switch to English

التدريب الموزع مع TensorFlow

عرض على TensorFlow.org تشغيل في Google Colab عرض المصدر على جيثب تنزيل دفتر الملاحظات

نظرة عامة

tf.distribute.Strategy عبارة عن واجهة برمجة تطبيقات TensorFlow لتوزيع التدريب عبر وحدات معالجة رسومات متعددة أو أجهزة متعددة أو وحدات TPU. باستخدام واجهة برمجة التطبيقات هذه ، يمكنك توزيع نماذجك الحالية وكود التدريب بأقل تغييرات في الكود.

تم تصميم tf.distribute.Strategy مع وضع الأهداف الرئيسية في الاعتبار:

  • سهل الاستخدام ويدعم قطاعات متعددة من المستخدمين ، بما في ذلك الباحثين ومهندسي ML وما إلى ذلك.
  • تقديم أداء جيد خارج الصندوق.
  • التبديل السهل بين الاستراتيجيات.

يمكن استخدام tf.distribute.Strategy مع واجهة برمجة تطبيقات عالية المستوى مثل Keras ، ويمكن استخدامها أيضًا لتوزيع حلقات تدريب مخصصة (وبشكل عام ، أي حساب باستخدام TensorFlow).

في TensorFlow 2.x ، يمكنك تنفيذ برامجك بلهفة ، أو في رسم بياني باستخدام tf.function تهدف tf.distribute.Strategy إلى دعم وضعَي التنفيذ هذين ، ولكنها تعمل بشكل أفضل مع tf.function يوصى بوضع Eager فقط لغرض التصحيح ولا يتم دعمه TPUStrategy . على الرغم من أننا نناقش التدريب معظم الوقت في هذا الدليل ، يمكن أيضًا استخدام واجهة برمجة التطبيقات هذه لتوزيع التقييم والتنبؤ على منصات مختلفة.

يمكنك استخدام tf.distribute.Strategy مع تغييرات قليلة جدًا في التعليمات البرمجية الخاصة بك ، لأننا قمنا بتغيير المكونات الأساسية لـ TensorFlow لتصبح على دراية بالاستراتيجية. وهذا يشمل المتغيرات والطبقات والنماذج والمحسنات والمقاييس والملخصات ونقاط التفتيش.

في هذا الدليل ، نوضح أنواعًا مختلفة من الاستراتيجيات وكيف يمكنك استخدامها في مواقف مختلفة.

 # Import TensorFlow
import tensorflow as tf
 

أنواع الاستراتيجيات

تهدف tf.distribute.Strategy إلى تغطية عدد من حالات الاستخدام عبر محاور مختلفة. بعض هذه المجموعات مدعوم حاليًا وستتم إضافة البعض الآخر في المستقبل. بعض هذه المحاور هي:

  • التدريب المتزامن مقابل التدريب غير المتزامن: هاتان طريقتان شائعتان لتوزيع التدريب بالتوازي مع البيانات. في التدريب على المزامنة ، يتدرب جميع العاملين على شرائح مختلفة من بيانات الإدخال في المزامنة ، ويجمعون التدرجات في كل خطوة. في التدريب غير المتزامن ، يتم تدريب جميع العاملين بشكل مستقل على بيانات الإدخال وتحديث المتغيرات بشكل غير متزامن. عادة ما يتم دعم التدريب على المزامنة عبر الحد الأدنى وغير المتزامن من خلال بنية خادم المعلمة.
  • النظام الأساسي للأجهزة: قد ترغب في توسيع نطاق التدريب الخاص بك إلى وحدات معالجة رسومات متعددة على جهاز واحد ، أو أجهزة متعددة في شبكة (مع 0 أو أكثر من وحدات معالجة الرسومات لكل منها) ، أو على Cloud TPUs.

من أجل دعم حالات الاستخدام هذه ، هناك ست استراتيجيات متاحة. سنشرح في القسم التالي أيًا مما يلي مدعوم في أي سيناريوهات في TF 2.2 في هذا الوقت. هنا لمحة سريعة:

API للتدريب الإستراتيجية استراتيجية TPUS MultiWorkerMirrored إستراتيجية استراتيجية التخزين المركزي ParameterServerStr Strategy
Keras API أيد أيد دعم تجريبي دعم تجريبي دعم وظيفة المخطط 2.3
حلقة تدريب مخصصة أيد أيد دعم تجريبي دعم تجريبي دعم وظيفة المخطط 2.3
API المُقدِّر دعم محدود غير مدعوم دعم محدود دعم محدود دعم محدود

الإستراتيجية

تدعم tf.distribute.MirroredStrategy التدريب الموزع المتزامن على وحدات معالجة tf.distribute.MirroredStrategy متعددة على جهاز واحد. يقوم بإنشاء نسخة متماثلة واحدة لكل جهاز GPU. يتم عكس كل متغير في النموذج عبر جميع النسخ المتماثلة. تشكل هذه المتغيرات معًا متغيرًا تصوريًا واحدًا يسمى MirroredVariable . تتم مزامنة هذه المتغيرات مع بعضها البعض من خلال تطبيق تحديثات متطابقة.

يتم استخدام خوارزميات فعالة لتقليل التحديثات المتغيرة عبر الأجهزة. All-تقليل مجمعات tensors عبر جميع الأجهزة عن طريق إضافتها ، وإتاحتها على كل جهاز. إنها خوارزمية تنصهر فعالة للغاية ويمكن أن تقلل من التزامن بشكل كبير. هناك العديد من الخوارزميات وعمليات التنفيذ المتاحة ، اعتمادًا على نوع الاتصال المتاح بين الأجهزة. بشكل افتراضي ، يستخدم NVIDIA NCCL كتطبيق كامل. يمكنك الاختيار من بين بعض الخيارات الأخرى التي نقدمها ، أو كتابة خياراتك الخاصة.

فيما يلي أبسط طريقة لإنشاء استراتيجية MirroredStrategy :

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

سيؤدي هذا إلى إنشاء مثيل MirroredStrategy الذي سيستخدم جميع وحدات معالجة الرسومات المرئية لـ TensorFlow ، ويستخدم NCCL كتواصل عبر الأجهزة.

إذا كنت ترغب في استخدام بعض وحدات معالجة الرسومات فقط على جهازك ، فيمكنك القيام بذلك على النحو التالي:

 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:0,/job:localhost/replica:0/task:0/device:GPU:1
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 (TPU). تُعد وحدات TPU عبارة عن ASICs المتخصصة من Google والمصممة لتسريع أعباء عمل التعلم الآلي بشكل كبير. وهي متوفرة على Google Colab و TensorFlow Research Cloud و Cloud TPU .

من حيث هندسة التدريب الموزع ، TPUStrategy هي نفس MirroredStrategy TPUStrategy - إنها تنفذ التدريب الموزع المتزامن. توفر 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. في Colab ، لا تحتاج إلى تحديد أي وسيطات لها.

إذا كنت ترغب في استخدام هذا لـ Cloud TPUs:

  • يجب تحديد اسم مورد TPU في وسيطة tpu .
  • يجب عليك تهيئة نظام tpu بشكل صريح في بداية البرنامج. هذا مطلوب قبل أن يمكن استخدام TPUs للحساب. تؤدي تهيئة نظام tpu أيضًا إلى محو ذاكرة TPU ، لذلك من المهم إكمال هذه الخطوة أولاً لتجنب فقدان الحالة.

MultiWorkerMirrored إستراتيجية

tf.distribute.experimental.MultiWorkerMirroredStrategy تشبه إلى حد بعيد tf.distribute.experimental.MultiWorkerMirroredStrategy MirroredStrategy . ينفذ التدريب الموزع المتزامن عبر عدة عمال ، مع كل وحدة معالجة رسومات محتملة. على غرار MirroredStrategy ، تقوم بإنشاء نسخ من جميع المتغيرات في النموذج على كل جهاز عبر جميع العاملين.

يستخدم CollectiveOps كطريقة تواصل متعددة العاملين لتقليل جميع المتغيرات المستخدمة للحفاظ على المتغيرات متزامنة. المرجع الجماعي عبارة عن مرجع منفرد في الرسم البياني TensorFlow والذي يمكنه تلقائيًا اختيار خوارزمية كل تخفيض في وقت تشغيل TensorFlow وفقًا للأجهزة وطبولوجيا الشبكة وأحجام الموتر.

كما أنها تنفذ تحسينات أداء إضافية. على سبيل المثال ، يتضمن تحسينًا ثابتًا يحول العديد من التخفيضات على أجهزة التينور الصغيرة إلى عدد أقل من عمليات التخفيض على أجهزة التنسور الأكبر حجمًا. بالإضافة إلى ذلك ، نقوم بتصميمه ليكون له بنية مكون إضافي - حتى تتمكن في المستقبل من خوارزميات المكونات الإضافية التي يتم ضبطها بشكل أفضل لجهازك. لاحظ أن العمليات الجماعية تنفذ أيضًا عمليات جماعية أخرى مثل البث والتجمع.

فيما يلي أبسط طريقة لإنشاء MultiWorkerMirroredStrategy :

 multiworker_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 حاليًا بالاختيار بين تطبيقين مختلفين MultiWorkerMirroredStrategy الجماعية. CollectiveCommunication.RING بتنفيذ CollectiveCommunication.RING تعتمد على الحلقة باستخدام gRPC كطبقة اتصال. يستخدم CollectiveCommunication.NCCL NCCidia's NCCL لتنفيذ المجموعات. CollectiveCommunication.AUTO يرجئ الاختيار إلى وقت التشغيل. يعتمد الاختيار الأفضل للتنفيذ الجماعي على عدد ونوع وحدات معالجة الرسومات ووصلات الشبكة في المجموعة. يمكنك تحديدها بالطريقة التالية:

 multiworker_strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy(
    tf.distribute.experimental.CollectiveCommunication.NCCL)
 
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.NCCL

أحد الاختلافات الرئيسية لبدء تدريب العاملين المتعددين ، مقارنة بالتدريب متعدد GPU ، هو الإعداد متعدد العاملين. متغير البيئة TF_CONFIG هو الطريقة القياسية في TensorFlow لتحديد تكوين الكتلة لكل عامل يمثل جزءًا من المجموعة. اعرف المزيد حول إعداد TF_CONFIG .

استراتيجية التخزين المركزي

تقوم 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 والذي سيستخدم جميع وحدات معالجة الرسومات ووحدة المعالجة المركزية المرئية. سيتم تجميع التحديث إلى المتغيرات في النسخ المتماثلة قبل تطبيقها على المتغيرات.

ParameterServerStr Strategy

يدعم tf.distribute.experimental.ParameterServerStrategy تدريب خوادم المعلمات على أجهزة متعددة. في هذا الإعداد ، يتم تعيين بعض الأجهزة كعمال وبعضها كخوادم معلمات. يتم وضع كل متغير من النموذج على خادم معلمة واحد. يتم نسخ الحساب عبر جميع وحدات معالجة الرسومات لجميع العمال.

من حيث الكود ، تبدو مشابهة للاستراتيجيات الأخرى:

 ps_strategy = tf.distribute.experimental.ParameterServerStrategy()
 

بالنسبة للتدريب متعدد العاملين ، يحتاج TF_CONFIG إلى تحديد تكوين خوادم المعلمات والعاملين في مجموعتك ، والتي يمكنك قراءة المزيد عنها في TF_CONFIG أدناه .

استراتيجيات أخرى

بالإضافة إلى الاستراتيجيات المذكورة أعلاه ، هناك استراتيجيتان أخريان قد تكون مفيدة للنماذج الأولية وتصحيح الأخطاء عند استخدام tf.distribute APIs.

الإستراتيجية الافتراضية

الاستراتيجية الافتراضية هي استراتيجية توزيع موجودة عندما لا توجد استراتيجية توزيع واضحة في النطاق. وهي تنفذ واجهة tf.distribute.Strategy ولكنها تمريرية ولا تقدم أي توزيع فعلي. على سبيل المثال ، ستقوم strategy.run(fn) ببساطة باستدعاء fn . يجب أن تتصرف الشفرة المكتوبة باستخدام هذه الإستراتيجية تمامًا مثل الشفرة المكتوبة بدون أي إستراتيجية. يمكنك التفكير في الأمر على أنه استراتيجية "لا يوجد".

الإستراتيجية الافتراضية هي كلمة فردية - ولا يمكن للمرء إنشاء المزيد من الأمثلة عنها. يمكن الحصول عليها باستخدام tf.distribute.get_strategy() خارج نطاق أي إستراتيجية صريحة (نفس واجهة برمجة التطبيقات التي يمكن استخدامها للحصول على الإستراتيجية الحالية داخل نطاق إستراتيجية صريحة).

 default_strategy = tf.distribute.get_strategy()
 

تخدم هذه الاستراتيجية هدفين رئيسيين:

  • يسمح لكتابة كود مكتبة علم بالتوزيع دون قيد أو شرط. على سبيل المثال ، في المُحسِّن ، يمكننا القيام بـ 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>

استراتيجية OneDevice

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 عبارة عن واجهة برمجة تطبيقات عالية المستوى لبناء النماذج وتدريبها. من خلال الدمج في الواجهة الخلفية tf.keras ، جعلنا الأمر tf.keras بالنسبة لك لتوزيع تدريبك المكتوب في إطار تدريب model.fit باستخدام model.fit .

إليك ما تحتاج إلى تغييره في التعليمات البرمجية:

  1. قم بإنشاء مثيل من tf.distribute.Strategy المناسبة.
  2. نقل إنشاء نموذج Keras ومحسن ومقاييس داخل strategy.scope . نطاق.

ندعم جميع أنواع موديلات Keras - متسلسلة ووظيفية وفئات فرعية.

فيما يلي مقتطف من التعليمات البرمجية للقيام بذلك لطراز 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',)

استخدمنا في هذا المثال استراتيجية MirroredStrategy حتى نتمكن من تشغيلها على جهاز مزود بوحدات معالجة رسومات متعددة. Strategy.scope strategy.scope() تشير إلى Keras للاستراتيجية التي سيتم استخدامها لتوزيع التدريب. يسمح لنا إنشاء نماذج / محسنات / مقاييس داخل هذا النطاق بإنشاء متغيرات موزعة بدلاً من المتغيرات العادية. بمجرد إعداد هذا ، يمكنك أن تناسب النموذج الخاص بك كما تفعل عادةً. تهتم MirroredStrategy بتكرار تدريب النموذج على وحدات معالجة الرسومات المتاحة ، وتجميع التدرجات ، والمزيد.

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

0.27546340227127075

استخدمنا هنا مجموعة بيانات 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
10/10 [==============================] - 0s 1ms/step - loss: 0.1961
Epoch 2/2
10/10 [==============================] - 0s 1ms/step - loss: 0.0867

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

في كلتا الحالتين (مجموعة بيانات أو رقم) ، يتم تقسيم كل دفعة من المدخلات المعادلة بالتساوي بين النسخ المتماثلة المتعددة. على سبيل المثال ، إذا كنت تستخدم MirroredStrategy مع MirroredStrategy GPU ، سيتم تقسيم كل دفعة من الحجم 10 بين وحدتي GPU ، مع تلقي كل 5 أمثلة إدخال في كل خطوة. بعد ذلك ، ستتدرب كل حقبة بشكل أسرع عند إضافة المزيد من وحدات معالجة الرسومات. بشكل عام ، قد ترغب في زيادة حجم الدفعة الخاصة بك حيث تقوم بإضافة المزيد من المسرعات من أجل الاستخدام الفعال لقوة الحوسبة الإضافية. ستحتاج أيضًا إلى إعادة ضبط معدل التعلم وفقًا للطراز. يمكنك استخدام 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 للتدريب الإستراتيجية استراتيجية TPUS MultiWorkerMirrored إستراتيجية استراتيجية التخزين المركزي ParameterServerStr Strategy
واجهات Keras أيد أيد دعم تجريبي دعم تجريبي دعم آخر المخطط 2.3

أمثلة ودروس

فيما يلي قائمة بالبرامج التعليمية والأمثلة التي توضح نهاية التكامل أعلاه مع Keras:

  1. برنامج تعليمي لتدريب MNIST مع MirroredStrategy Strategy.
  2. البرنامج التعليمي لتدريب MNIST باستخدام MultiWorkerMirroredStrategy .
  3. دليل تدريب MNIST باستخدام TPUStrategy .
  4. مستودع TensorFlow Model Garden يحتوي على مجموعات من أحدث النماذج التي تم تنفيذها باستخدام استراتيجيات مختلفة.

استخدام tf.distribute.Strategy مع حلقات التدريب المخصصة

كما رأيت ، فإن استخدام tf.distribute.Strategy مع Keras model.fit يتطلب تغيير سطرين فقط من التعليمات البرمجية الخاصة بك. مع مزيد من الجهد ، يمكنك أيضًا استخدام tf.distribute.Strategy مع حلقات تدريب مخصصة.

إذا كنت بحاجة إلى المزيد من المرونة والتحكم في حلقات التدريب الخاصة بك أكثر مما هو ممكن مع Estimator أو Keras ، يمكنك كتابة حلقات تدريب مخصصة. على سبيل المثال ، عند استخدام GAN ، قد ترغب في اتخاذ عدد مختلف من خطوات المولد أو التمييز في كل جولة. وبالمثل ، فإن الأطر عالية المستوى ليست مناسبة جدًا للتدريب على التعلم التعزيزي.

لدعم حلقات التدريب المخصصة ، نقدم مجموعة أساسية من الأساليب من خلال فئات tf.distribute.Strategy . قد يتطلب استخدام هذه إعادة هيكلة طفيفة للرمز في البداية ، ولكن بمجرد القيام بذلك ، يجب أن تكون قادرًا على التبديل بين وحدات معالجة الرسومات ووحدات TPU وأجهزة متعددة ببساطة عن طريق تغيير مثيل الاستراتيجية.

سنعرض هنا مقتطفًا موجزًا ​​يوضح حالة الاستخدام هذه للحصول على مثال تدريبي بسيط باستخدام نفس طراز 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 لحساب التدرجات tf.GradientTape لتطبيق هذه التدرجات لتحديث متغيرات نموذجنا. لتوزيع خطوة التدريب هذه ، نضع في وظيفة 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.run . يعرض tf.distribute.Strategy.run نتائج من كل نسخة متماثلة محلية في الاستراتيجية ، وهناك طرق متعددة لاستهلاك هذه النتيجة. يمكنك reduce للحصول على قيمة مجمعة. يمكنك أيضًا إجراء tf.distribute.Strategy.experimental_local_results للحصول على قائمة القيم الواردة في النتيجة ، واحدة لكل نسخة متماثلة محلية.
  3. عندما يتم استدعاء apply_gradients ضمن نطاق استراتيجية التوزيع ، يتم تعديل سلوكها. على وجه التحديد ، قبل تطبيق التدرجات على كل مثيل متوازي أثناء التدريب المتزامن ، فإنه يقوم بعمل مجموع لجميع النسخ المتماثلة للتدرجات.

أخيرًا ، بمجرد تحديد خطوة التدريب ، يمكننا dist_dataset عبر مجموعة بيانات dist_dataset وتشغيل التدريب في حلقة:

 for dist_inputs in dist_dataset:
  print(distributed_train_step(dist_inputs))
 
tf.Tensor(0.4155251, shape=(), dtype=float32)
tf.Tensor(0.41321823, shape=(), dtype=float32)
tf.Tensor(0.4109319, shape=(), dtype=float32)
tf.Tensor(0.40866604, shape=(), dtype=float32)
tf.Tensor(0.40642032, shape=(), dtype=float32)
tf.Tensor(0.40419456, shape=(), dtype=float32)
tf.Tensor(0.4019885, shape=(), dtype=float32)
tf.Tensor(0.399802, shape=(), dtype=float32)
tf.Tensor(0.39763477, shape=(), dtype=float32)
tf.Tensor(0.3954866, shape=(), dtype=float32)
tf.Tensor(0.39335734, shape=(), dtype=float32)
tf.Tensor(0.3912467, shape=(), dtype=float32)
tf.Tensor(0.38915452, shape=(), dtype=float32)
tf.Tensor(0.38708064, shape=(), dtype=float32)
tf.Tensor(0.38502476, shape=(), dtype=float32)
tf.Tensor(0.38298675, shape=(), dtype=float32)
tf.Tensor(0.38096642, shape=(), dtype=float32)
tf.Tensor(0.3789635, shape=(), dtype=float32)
tf.Tensor(0.3769779, shape=(), dtype=float32)
tf.Tensor(0.37500936, shape=(), dtype=float32)

في المثال أعلاه ، قمنا dist_dataset عبر مجموعة dist_dataset لتوفير مدخلات dist_dataset . كما نقدم مجموعة tf.distribute.Strategy.make_experimental_numpy_dataset لدعم المدخلات غير المعلومة. يمكنك استخدام واجهة برمجة التطبيقات هذه لإنشاء مجموعة بيانات قبل استدعاء tf.distribute.Strategy.experimental_distribute_dataset .

طريقة أخرى لتكرار بياناتك هي استخدام التكرارات بشكل صريح. قد ترغب في القيام بذلك عندما تريد الترشح لعدد معين من الخطوات بدلاً من التكرار عبر مجموعة البيانات بأكملها. سيتم تعديل التكرار أعلاه الآن لإنشاء مكرر أولاً ثم استدعاء next بشكل صريح للحصول على بيانات الإدخال.

 iterator = iter(dist_dataset)
for _ in range(10):
  print(distributed_train_step(next(iterator)))
 
tf.Tensor(0.37305772, shape=(), dtype=float32)
tf.Tensor(0.3711228, shape=(), dtype=float32)
tf.Tensor(0.3692044, shape=(), dtype=float32)
tf.Tensor(0.36730233, shape=(), dtype=float32)
tf.Tensor(0.3654165, shape=(), dtype=float32)
tf.Tensor(0.36354658, shape=(), dtype=float32)
tf.Tensor(0.36169255, shape=(), dtype=float32)
tf.Tensor(0.3598542, shape=(), dtype=float32)
tf.Tensor(0.35803124, shape=(), dtype=float32)
tf.Tensor(0.3562236, shape=(), dtype=float32)

يغطي هذا الحالة الأبسط لاستخدام tf.distribute.Strategy API لتوزيع حلقات التدريب المخصصة. نحن بصدد تحسين واجهات برمجة التطبيقات هذه. نظرًا لأن حالة الاستخدام هذه تتطلب مزيدًا من العمل لتكييف شفرتك ، فسننشر دليلًا مفصلاً منفصلاً في المستقبل.

ما المدعوم الآن؟

API للتدريب الإستراتيجية استراتيجية TPUS MultiWorkerMirrored إستراتيجية استراتيجية التخزين المركزي ParameterServerStr Strategy
حلقة تدريب مخصصة أيد أيد دعم تجريبي دعم تجريبي دعم آخر المخطط 2.3

أمثلة ودروس

فيما يلي بعض الأمثلة لاستخدام استراتيجية التوزيع مع حلقات التدريب المخصصة:

  1. برنامج تعليمي لتدريب MNIST باستخدام MirroredStrategy .
  2. دليل تدريب MNIST باستخدام TPUStrategy .
  3. مستودع TensorFlow Model Garden يحتوي على مجموعات من أحدث النماذج التي تم تنفيذها باستخدام استراتيجيات مختلفة.

استخدام tf.distribute.Strategy مع المُقدِّر (دعم محدود)

tf.estimator هو TensorFlow API للتدريب الموزع الذي دعم في الأصل نهج خادم المعلمة غير المتزامن. كما هو الحال مع Keras ، قمنا بدمج tf.distribute.Strategy في tf.Estimator . إذا كنت تستخدم المُقدِّر لتدريبك ، فيمكنك بسهولة التغيير إلى التدريب الموزع مع تغييرات قليلة جدًا على التعليمات البرمجية الخاصة بك. من خلال هذا ، يمكن لمستخدمي المُقدِّر الآن إجراء تدريب موزّع متزامن على وحدات معالجة رسومات متعددة وعاملين متعددين ، بالإضافة إلى استخدام TPU. هذا الدعم في المُقدِّر ، مع ذلك ، محدود. راجع قسم ما هو مدعوم الآن أدناه لمزيد من التفاصيل.

استخدام tf.distribute.Strategy مع المُقدر يختلف قليلاً عن حالة Keras. بدلا من استخدام strategy.scope ، ونحن الآن تمرير الكائن الاستراتيجية في RunConfig للمقدر.

في ما يلي مقتطف من الشفرة يظهر هذا مع مقدِّر LinearRegressor و MirroredStrategy LinearRegressor :

 mirrored_strategy = tf.distribute.MirroredStrategy()
config = tf.estimator.RunConfig(
    train_distribute=mirrored_strategy, eval_distribute=mirrored_strategy)
regressor = tf.estimator.LinearRegressor(
    feature_columns=[tf.feature_column.numeric_column('feats')],
    optimizer='SGD',
    config=config)
 
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)
INFO:tensorflow:Initializing RunConfig with distribution strategies.
INFO:tensorflow:Not using Distribute Coordinator.
WARNING:tensorflow:Using temporary folder as model directory: /tmp/tmp2ack9oru
INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmp2ack9oru', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': allow_soft_placement: true
graph_options {
  rewrite_options {
    meta_optimizer_iterations: ONE
  }
}
, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': <tensorflow.python.distribute.mirrored_strategy.MirroredStrategy object at 0x7fa124522b38>, '_device_fn': None, '_protocol': None, '_eval_distribute': <tensorflow.python.distribute.mirrored_strategy.MirroredStrategy object at 0x7fa124522b38>, '_experimental_distribute': None, '_experimental_max_worker_delay_secs': None, '_session_creation_timeout_secs': 7200, '_service': None, '_cluster_spec': ClusterSpec({}), '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1, '_distribute_coordinator_mode': None}

نحن نستخدم مقدِّرًا سابقًا هنا ، ولكن يعمل الرمز نفسه مع مقدر مخصص أيضًا. يحدد train_distribute كيفية توزيع التدريب ، ويحدد eval_distribute كيفية توزيع التقييم. هذا اختلاف آخر عن Keras حيث نستخدم نفس الاستراتيجية للتدريب والتقييم.

الآن يمكننا تدريب وتقييم هذا المُقدِّر باستخدام وظيفة الإدخال:

 def input_fn():
  dataset = tf.data.Dataset.from_tensors(({"feats":[1.]}, [1.]))
  return dataset.repeat(1000).batch(10)
regressor.train(input_fn=input_fn, steps=10)
regressor.evaluate(input_fn=input_fn, steps=10)
 
INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow_estimator/python/estimator/canned/linear.py:1481: Layer.add_variable (from tensorflow.python.keras.engine.base_layer_v1) is deprecated and will be removed in a future version.
Instructions for updating:
Please use `layer.add_weight` method instead.
INFO:tensorflow:Done calling model_fn.
WARNING:tensorflow:AutoGraph could not transform <function _combine_distributed_scaffold.<locals>.<lambda> at 0x7fa12452cb70> and will run it as-is.
Cause: could not parse the source code:

      lambda scaffold: scaffold.ready_op, args=(grouped_scaffold,))

This error may be avoided by creating the lambda in a standalone statement.

To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert
WARNING: AutoGraph could not transform <function _combine_distributed_scaffold.<locals>.<lambda> at 0x7fa12452cb70> and will run it as-is.
Cause: could not parse the source code:

      lambda scaffold: scaffold.ready_op, args=(grouped_scaffold,))

This error may be avoided by creating the lambda in a standalone statement.

To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert
INFO:tensorflow:Create CheckpointSaverHook.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow_estimator/python/estimator/util.py:96: DistributedIteratorV1.initialize (from tensorflow.python.distribute.input_lib) is deprecated and will be removed in a future version.
Instructions for updating:
Use the iterator's `initializer` property instead.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 0...
INFO:tensorflow:Saving checkpoints for 0 into /tmp/tmp2ack9oru/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 0...
INFO:tensorflow:loss = 1.0, step = 0
INFO:tensorflow:Calling checkpoint listeners before saving checkpoint 10...
INFO:tensorflow:Saving checkpoints for 10 into /tmp/tmp2ack9oru/model.ckpt.
INFO:tensorflow:Calling checkpoint listeners after saving checkpoint 10...
INFO:tensorflow:Loss for final step: 2.877698e-13.
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
WARNING:tensorflow:AutoGraph could not transform <function _combine_distributed_scaffold.<locals>.<lambda> at 0x7fa1e9768d08> and will run it as-is.
Cause: could not parse the source code:

      lambda scaffold: scaffold.ready_op, args=(grouped_scaffold,))

This error may be avoided by creating the lambda in a standalone statement.

To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert
WARNING: AutoGraph could not transform <function _combine_distributed_scaffold.<locals>.<lambda> at 0x7fa1e9768d08> and will run it as-is.
Cause: could not parse the source code:

      lambda scaffold: scaffold.ready_op, args=(grouped_scaffold,))

This error may be avoided by creating the lambda in a standalone statement.

To silence this warning, decorate the function with @tf.autograph.experimental.do_not_convert
INFO:tensorflow:Starting evaluation at 2020-08-04T20:28:12Z
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from /tmp/tmp2ack9oru/model.ckpt-10
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [1/10]
INFO:tensorflow:Evaluation [2/10]
INFO:tensorflow:Evaluation [3/10]
INFO:tensorflow:Evaluation [4/10]
INFO:tensorflow:Evaluation [5/10]
INFO:tensorflow:Evaluation [6/10]
INFO:tensorflow:Evaluation [7/10]
INFO:tensorflow:Evaluation [8/10]
INFO:tensorflow:Evaluation [9/10]
INFO:tensorflow:Evaluation [10/10]
INFO:tensorflow:Inference Time : 0.20350s
INFO:tensorflow:Finished evaluation at 2020-08-04-20:28:12
INFO:tensorflow:Saving dict for global step 10: average_loss = 1.4210855e-14, global_step = 10, label/mean = 1.0, loss = 1.4210855e-14, prediction/mean = 0.99999994
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 10: /tmp/tmp2ack9oru/model.ckpt-10

{'average_loss': 1.4210855e-14,
 'label/mean': 1.0,
 'loss': 1.4210855e-14,
 'prediction/mean': 0.99999994,
 'global_step': 10}

هناك فرق آخر يجب تسليط الضوء عليه هنا بين المُقدِّر و Keras وهو معالجة الإدخال. في Keras ، ذكرنا أن كل دفعة من مجموعة البيانات يتم تقسيمها تلقائيًا عبر النسخ المتماثلة المتعددة. ومع ذلك ، في المقدر ، لا نقوم بتقسيم الدُفعة تلقائيًا ، ولا نقوم تلقائيًا بجمع البيانات عبر العمال المختلفين. لديك تحكم كامل في الطريقة التي تريد أن يتم توزيع بياناتك بها على العمال والأجهزة ، ويجب عليك تقديم input_fn لتحديد كيفية توزيع بياناتك.

يتم استدعاء input_fn مرة واحدة لكل عامل ، وبالتالي إعطاء مجموعة بيانات واحدة لكل عامل. ثم يتم تغذية دفعة واحدة من مجموعة البيانات هذه إلى نسخة متماثلة واحدة على هذا العامل ، وبالتالي استهلاك دفعات N للنسخ المتماثلة N لعامل واحد. بمعنى آخر ، يجب أن توفر مجموعة البيانات التي تم إرجاعها بواسطة input_fn دفعات من الحجم PER_REPLICA_BATCH_SIZE . ويمكن الحصول على حجم الدفعة العامة لخطوة على النحو PER_REPLICA_BATCH_SIZE * strategy.num_replicas_in_sync . PER_REPLICA_BATCH_SIZE * strategy.num_replicas_in_sync .

عند القيام بتدريب عاملين متعددين ، يجب عليك إما تقسيم بياناتك عبر العمال ، أو خلطها مع بذور عشوائية لكل منها. يمكنك أن ترى مثالاً لكيفية القيام بذلك في التدريب متعدد العمال باستخدام المُقدِّر .

وبالمثل ، يمكنك استخدام استراتيجيات خادم متعدد العمال والمعلمات أيضًا. يظل الرمز كما هو ، ولكنك تحتاج إلى استخدام tf.estimator.train_and_evaluate ، وتعيين متغيرات بيئة TF_CONFIG لكل ثنائي يعمل في مجموعتك.

ما المدعوم الآن؟

هناك دعم محدود للتدريب باستخدام المُقدِّر باستخدام جميع الإستراتيجيات باستثناء TPUStrategy . يجب أن يعمل التدريب والتقييم الأساسيان ، لكن عددًا من الميزات المتقدمة مثل السقالة لا تعمل بعد. قد يكون هناك أيضًا عدد من الأخطاء في هذا التكامل. في الوقت الحالي ، لا نخطط لتحسين هذا الدعم بنشاط ، وبدلاً من ذلك نركز على Keras ودعم حلقة التدريب المخصصة. إذا كان ذلك ممكنًا ، يجب أن تفضل استخدام tf.distribute مع واجهات برمجة التطبيقات هذه بدلاً من ذلك.

API للتدريب الإستراتيجية استراتيجية TPUS MultiWorkerMirrored إستراتيجية استراتيجية التخزين المركزي ParameterServerStr Strategy
API المُقدِّر دعم محدود غير مدعوم دعم محدود دعم محدود دعم محدود

أمثلة ودروس

في ما يلي بعض الأمثلة التي توضح الاستخدام الكامل للاستراتيجيات المختلفة مع المُقدِّر:

  1. تدريب متعدد العاملين مع المُقدر لتدريب MNIST مع عدة عمال باستخدام MultiWorkerMirroredStrategy .
  2. مثال من النهاية إلى النهاية لتدريب عدة عمال في tensorflow / النظام البيئي باستخدام قوالب Kubernetes. يبدأ هذا المثال بنموذج Keras ويحوله إلى مقدر باستخدام tf.keras.estimator.model_to_estimator API.
  3. نموذج ResNet50 الرسمي ، والذي يمكن تدريبه باستخدام MirroredStrategy أو MultiWorkerMirroredStrategy .

موضوعات أخرى

في هذا القسم ، سنتناول بعض الموضوعات ذات الصلة بحالات الاستخدام المتعددة.

إعداد متغير بيئة TF_CONFIG

للتدريب متعدد العاملين ، كما ذكرنا من قبل ، تحتاج إلى تعيين متغير بيئة TF_CONFIG لكل ثنائي يعمل في مجموعتك. متغير البيئة TF_CONFIG عبارة عن سلسلة JSON تحدد المهام التي تشكل مجموعة وعناوينها ودور كل مهمة في المجموعة. نحن نقدم نموذج Kubernetes في tensorflow / إعادة النظام البيئي الذي يحدد TF_CONFIG لمهام التدريب الخاصة بك.

هناك مكونان من TF_CONFIG: الكتلة والمهمة. يوفر الكتلة معلومات حول مجموعة التدريب ، وهو عبارة عن إملاء يتكون من أنواع مختلفة من الوظائف مثل العامل. في التدريب متعدد العمال ، عادة ما يكون هناك عامل واحد يتحمل المزيد من المسؤولية مثل حفظ نقطة التفتيش وكتابة ملف ملخص لـ TensorBoard بالإضافة إلى ما يفعله العامل العادي. يُشار إلى هذا العامل باسم العامل "الرئيسي" ، ومن المعتاد أن يتم تعيين العامل ذو المؤشر 0 كعامل رئيسي (في الواقع هذه هي الطريقة التي يتم بها تنفيذ tf.distribute. الاستراتيجية). المهمة من ناحية أخرى توفر معلومات عن المهمة الحالية. مجموعة المكون الأول هي نفسها لجميع العمال ، ومهمة المكون الثاني تختلف عن كل عامل وتحدد نوع هذا العامل وفهرسته.

أحد أمثلة 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 أن هناك ثلاثة عمال TF_CONFIG ps في المجموعة مع المضيفين والمنافذ. يحدد الجزء "مهمة" أن دور المهمة الحالية في الكتلة ، العامل 1 (العامل الثاني). الأدوار الصالحة في المجموعة هي "رئيسي" و "عامل" و "ps" و "مقيم". يجب ألا تكون هناك وظيفة "ps" إلا عند استخدام tf.distribute.experimental.ParameterServerStrategy .

ماذا بعد؟

tf.distribute.Strategy قيد التطوير بنشاط. نرحب بك لتجربتها وتقديم ملاحظاتك باستخدام مشكلات GitHub .