इस पेज का अनुवाद Cloud Translation API से किया गया है.
Switch to English

TensorFlow के साथ वितरित प्रशिक्षण

TensorFlow.org पर देखें Google Colab में चलाएं GitHub पर स्रोत देखें नोटबुक डाउनलोड करें

अवलोकन

tf.distribute.Strategy कई GPU, कई मशीनों या TPU में प्रशिक्षण वितरित करने के लिए एक TensorFlow API है। इस एपीआई का उपयोग करके, आप अपने मौजूदा मॉडल और प्रशिक्षण कोड को न्यूनतम कोड परिवर्तन के साथ वितरित कर सकते हैं।

tf.distribute.Strategy को इन प्रमुख लक्ष्यों को ध्यान में रखकर तैयार किया गया है:

  • शोधकर्ताओं, एमएल इंजीनियरों आदि सहित कई उपयोगकर्ता खंडों का उपयोग और समर्थन करना आसान है।
  • बॉक्स से बाहर अच्छा प्रदर्शन प्रदान करें।
  • रणनीतियों के बीच आसान स्विचिंग।

tf.distribute.Strategy की तरह एक उच्च स्तरीय एपीआई के साथ इस्तेमाल किया जा सकता Keras (, और सामान्य रूप में TensorFlow उपयोग कर किसी भी गणना), और भी कस्टम प्रशिक्षण छोरों वितरित करने के लिए इस्तेमाल किया जा सकता।

TensorFlow 2.x में, आप अपने कार्यक्रमों को उत्सुकता से, या ग्राफ़ में tf.function का उपयोग करके tf.function कर tf.functiontf.distribute.Strategy ने निष्पादन के इन दोनों तरीकों का समर्थन करने का इरादा किया है, लेकिन tf.function साथ सबसे अच्छा काम करता है। उत्सुक मोड केवल डीबगिंग उद्देश्य के लिए अनुशंसित है और TPUStrategy लिए समर्थित नहीं है। यद्यपि हम इस गाइड में अधिकांश समय प्रशिक्षण पर चर्चा करते हैं, इस एपीआई का उपयोग विभिन्न प्लेटफार्मों पर मूल्यांकन और भविष्यवाणी को वितरित करने के लिए भी किया जा सकता है।

आप अपने कोड में बहुत कम परिवर्तनों के साथ tf.distribute.Strategy उपयोग कर सकते हैं, क्योंकि हमने रणनीति-जागरूक बनने के लिए TensorFlow के अंतर्निहित घटकों को बदल दिया है। इसमें चर, परतें, मॉडल, ऑप्टिमाइज़र, मीट्रिक, सारांश और चौकियाँ शामिल हैं।

इस गाइड में, हम विभिन्न प्रकार की रणनीतियों की व्याख्या करते हैं और आप उन्हें विभिन्न स्थितियों में कैसे उपयोग कर सकते हैं।

# Import TensorFlow
import tensorflow as tf

रणनीतियों के प्रकार

tf.distribute.Strategy विभिन्न अक्षों के साथ कई उपयोग मामलों को कवर करने का इरादा रखता है। इनमें से कुछ संयोजन वर्तमान में समर्थित हैं और अन्य भविष्य में जोड़े जाएंगे। इनमें से कुछ कुल्हाड़ी हैं:

  • सिंक्रोनस बनाम एसिंक्रोनस प्रशिक्षण: ये डेटा समानता के साथ प्रशिक्षण वितरित करने के दो सामान्य तरीके हैं। सिंक प्रशिक्षण में, सभी कार्यकर्ता सिंक में इनपुट डेटा के विभिन्न स्लाइस पर प्रशिक्षण देते हैं, और प्रत्येक चरण पर ग्रेडिएंट एकत्रित करते हैं। Async प्रशिक्षण में, सभी कार्यकर्ता स्वतंत्र रूप से इनपुट डेटा पर प्रशिक्षण दे रहे हैं और चर को अतुल्यकालिक रूप से अपडेट कर रहे हैं। आमतौर पर सिंक प्रशिक्षण सभी को कम करने और पैरामीटर सर्वर आर्किटेक्चर के माध्यम से एसिंक्स के माध्यम से समर्थित है।
  • हार्डवेयर प्लेटफ़ॉर्म: आप अपने प्रशिक्षण को एक मशीन पर, या एक नेटवर्क में कई मशीनों (0 या अधिक जीपीयू के साथ), या क्लाउड टीपीयू पर अपने प्रशिक्षण को स्केल करना चाहते हैं।

इन उपयोग मामलों का समर्थन करने के लिए, छह रणनीतियाँ उपलब्ध हैं। अगले भाग में हम बताते हैं कि इस समय TF 2.2 में कौन से परिदृश्य समर्थित हैं। यहाँ एक त्वरित अवलोकन है:

प्रशिक्षण एपीआई MirroredStrategy TPUStrategy MultiWorkerMirroredStrategy CentralStorageStrategy ParameterServerStrategy
करेस एपीआई समर्थित समर्थित प्रायोगिक समर्थन प्रायोगिक समर्थन समर्थित योजना 2.3 पोस्ट की गई
कस्टम प्रशिक्षण पाश समर्थित समर्थित प्रायोगिक समर्थन प्रायोगिक समर्थन समर्थित नियोजित पोस्ट 2.3
अनुमानक एपीआई सीमित समर्थन समर्थित नहीं सीमित समर्थन सीमित समर्थन सीमित समर्थन

MirroredStrategy

tf.distribute.MirroredStrategy एक मशीन पर कई GPU पर तुल्यकालिक वितरित प्रशिक्षण का समर्थन करता है। यह 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 उदाहरण बनाएगा जो सभी GPU का उपयोग करेगा जो TensorFlow के लिए दिखाई देते हैं, और क्रॉस डिवाइस संचार के रूप में NCCL का उपयोग करेंगे।

यदि आप अपनी मशीन पर केवल कुछ GPU का उपयोग करना चाहते हैं, तो आप ऐसा कर सकते हैं:

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',)

TPUStrategy

tf.distribute.TPUStrategy आपको Tensor Processing Unit (TPUs) पर अपना TensorFlow प्रशिक्षण चलाने की सुविधा देता है। TPU, Google के विशेष ASIC हैं जिन्हें नाटकीय रूप से मशीन लर्निंग वर्कलोड में तेजी लाने के लिए डिज़ाइन किया गया है। वे Google Colab, TensorFlow Research Cloud और Cloud TPU पर उपलब्ध हैं

वितरित प्रशिक्षण वास्तुकला के संदर्भ में, TPUStrategy ही है MirroredStrategy - यह तुल्यकालिक वितरित प्रशिक्षण लागू करता है। TPUStrategy कई TPUStrategy कोर में कुशल सभी-कम और अन्य सामूहिक संचालन के अपने स्वयं के कार्यान्वयन प्रदान करते हैं, जो कि TPUStrategy में उपयोग किए TPUStrategy

यहां बताया गया है कि आप 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 में, आपको इसके लिए कोई तर्क निर्दिष्ट करने की आवश्यकता नहीं है।

यदि आप क्लाउड टीपीयू के लिए इसका उपयोग करना चाहते हैं:

  • आपको tpu तर्क में अपने TPU संसाधन का नाम निर्दिष्ट करना होगा।
  • आपको प्रोग्राम के प्रारंभ में स्पष्ट रूप से tpu प्रणाली को इनिशियलाइज़ करना होगा। टीपीयू को गणना के लिए इस्तेमाल करने से पहले यह आवश्यक है। Tpu प्रणाली को शुरू करने से TPU मेमोरी भी नष्ट हो जाती है, इसलिए राज्य खोने से बचने के लिए पहले इस चरण को पूरा करना महत्वपूर्ण है।

MultiWorkerMirroredStrategy

tf.distribute.experimental.MultiWorkerMirroredStrategy बहुत के समान है MirroredStrategy । यह कई श्रमिकों में सिंक्रोनस वितरित प्रशिक्षण को लागू करता है, प्रत्येक संभावित एकाधिक GPU के साथ। MirroredStrategy समान, यह सभी श्रमिकों के प्रत्येक डिवाइस पर मॉडल में सभी चर की प्रतियां बनाता है।

यह कलेक्टिवऑप्स का उपयोग करता है क्योंकि चर को सिंक में रखने के लिए उपयोग किए जाने वाले बहु-कार्यकर्ता संचार को कम करते हैं। एक सामूहिक ऑप 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 वर्तमान में आपको सामूहिक ऑप्स के दो अलग-अलग कार्यान्वयनों के बीच चयन करने की अनुमति देता है। CollectiveCommunication.RING संचार परत के रूप में gRPC का उपयोग करके रिंग-आधारित सामूहिक को लागू करता है। CollectiveCommunication.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

मल्टी-कार्यकर्ता प्रशिक्षण प्राप्त करने के लिए महत्वपूर्ण अंतरों में से एक, मल्टी-जीपीयू प्रशिक्षण की तुलना में, बहु-कार्यकर्ता सेटअप है। प्रत्येक कार्यकर्ता को क्लस्टर कॉन्फ़िगरेशन निर्दिष्ट करने के लिए TensorFlow में TF_CONFIG पर्यावरण चर मानक तरीका है जो क्लस्टर का हिस्सा है। TF_CONFIG सेट करने के बारे में और जानें।

CentralStorageStrategy

tf.distribute.experimental.CentralStorageStrategy समकालिक प्रशिक्षण भी करता है। चर को प्रतिबिंबित नहीं किया जाता है, इसके बजाय उन्हें सीपीयू पर रखा जाता है और सभी स्थानीय जीपीयू में संचालन को दोहराया जाता है। यदि केवल एक ही GPU है, तो सभी चर और संचालन उस GPU पर रखे जाएंगे।

CentralStorageStrategy द्वारा 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 उदाहरण CentralStorageStrategy जो सभी दृश्यमान GPU और CPU का उपयोग करेगा। चर पर लागू होने से पहले प्रतिकृतियों पर चर को अद्यतन किया जाएगा।

ParameterServerStrategy

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() कर सकते हैं और ग्रेडिएंट्स को कम करने के लिए उस रणनीति का उपयोग कर सकते हैं - यह हमेशा एक रणनीति ऑब्जेक्ट लौटाएगा जिस पर हम कम एपीआई को कॉल कर सकते हैं।
# 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 एक एकल निर्दिष्ट डिवाइस पर सभी चर और अभिकलन tf.distribute.OneDeviceStrategy की एक रणनीति है।

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

यह रणनीति कई तरीकों से डिफ़ॉल्ट रणनीति से अलग है। डिफ़ॉल्ट रणनीति में, बिना किसी वितरण रणनीति के TensorFlow चलाने की तुलना में चर प्लेसमेंट तर्क अपरिवर्तित रहता है। लेकिन OneDeviceStrategy का उपयोग करते OneDeviceStrategy , इसके दायरे में बनाए गए सभी चर स्पष्ट रूप से निर्दिष्ट डिवाइस पर रखे जाते हैं। इसके अलावा, OneDeviceStrategy.run माध्यम से OneDeviceStrategy.run किसी भी फ़ंक्शन को भी निर्दिष्ट डिवाइस पर रखा जाएगा।

इस रणनीति के माध्यम से वितरित इनपुट को निर्दिष्ट डिवाइस पर प्रीफ़ेट किया जाएगा। डिफ़ॉल्ट रणनीति में, कोई इनपुट वितरण नहीं है।

डिफ़ॉल्ट रणनीति के समान, इस रणनीति का उपयोग अन्य रणनीतियों पर स्विच करने से पहले आपके कोड का परीक्षण करने के लिए भी किया जा सकता है जो वास्तव में कई उपकरणों / मशीनों को वितरित करते हैं। यह वितरण रणनीति मशीनरी कुछ और अधिक डिफ़ॉल्ट कार्यनीति से व्यायाम करेंगे, लेकिन का उपयोग कर के रूप में पूर्ण सीमा तक के लिए नहीं MirroredStrategy या TPUStrategy आदि आप कोड चाहते हैं कि बर्ताव करता है के रूप में कोई रणनीति है, तो डिफ़ॉल्ट रणनीति का उपयोग करें।

अब तक हमने इस बारे में बात की है कि अलग-अलग रणनीतियाँ क्या उपलब्ध हैं और आप उन्हें कैसे त्वरित कर सकते हैं। अगले कुछ खंडों में, हम उन विभिन्न तरीकों के बारे में बात करेंगे जिनमें आप अपने प्रशिक्षण को वितरित करने के लिए उनका उपयोग कर सकते हैं। हम इस गाइड में शॉर्ट कोड स्निपेट्स दिखाएंगे और पूर्ण ट्यूटोरियल के लिए लिंक करेंगे जिसे आप अंत में समाप्त कर सकते हैं।

tf.distribute.Strategy साथ tf.keras.Model.fit का उपयोग करना

हम एकीकृत कर दिया है tf.distribute.Strategy में tf.keras की TensorFlow का क्रियान्वयन है जो Keras एपीआई विनिर्देशtf.keras मॉडल बनाने और प्रशिक्षित करने के लिए एक उच्च-स्तरीय एपीआई है। tf.keras बैकएंड में एकीकृत करके, हमने आपके लिए model.fit . model.fit का उपयोग करते हुए model.fit प्रशिक्षण ढांचे में लिखे गए अपने प्रशिक्षण को वितरित करना सहज बना दिया है।

यहां आपको अपने कोड में परिवर्तन करने की आवश्यकता है:

  1. उपयुक्त tf.distribute.Strategy का एक उदाहरण बनाएँ।
  2. Keras मॉडल, ऑप्टिमाइज़र और मेट्रिक्स के निर्माण को strategy.scope अंदर ले जाएँ।

हम सभी प्रकार के केरस मॉडल का समर्थन करते हैं - अनुक्रमिक, कार्यात्मक और उपवर्ग।

यहाँ एक घने परत के साथ एक बहुत ही सरल केरस मॉडल के लिए ऐसा करने के लिए कोड का एक टुकड़ा है:

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() 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: 3.4059
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: 1.5054
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: 0.9349

0.9348920583724976

यहाँ हमने एक 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 [==============================] - 0s 2ms/step - loss: 0.6654
Epoch 2/2
10/10 [==============================] - 0s 2ms/step - loss: 0.2941

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

दोनों मामलों में (डाटासेट या संख्यात्मक), दिए गए इनपुट के प्रत्येक बैच को समान रूप से कई प्रतिकृतियों में विभाजित किया गया है। उदाहरण के लिए, यदि 2 GPU के साथ MirroredStrategy का उपयोग किया जाता है, तो आकार 10 के प्रत्येक बैच को प्रत्येक चरण में 5 इनपुट उदाहरण प्राप्त करने के साथ, 2 GPU के बीच विभाजित किया जाएगा। जब आप अधिक GPU जोड़ते हैं, तब प्रत्येक युग तेजी से प्रशिक्षित होगा। आमतौर पर, आप अपने बैच का आकार बढ़ाना चाहते हैं क्योंकि आप अतिरिक्त त्वरक को जोड़ते हैं ताकि अतिरिक्त कंप्यूटिंग शक्ति का प्रभावी उपयोग किया जा सके। आपको मॉडल के आधार पर अपनी सीखने की दर को फिर से ट्यून करने की आवश्यकता होगी। प्रतिकृतियों की संख्या प्राप्त करने के लिए आप 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]

अब क्या समर्थित है?

प्रशिक्षण एपीआई MirroredStrategy TPUStrategy MultiWorkerMirroredStrategy CentralStorageStrategy ParameterServerStrategy
करस एपीआई समर्थित समर्थित प्रायोगिक समर्थन प्रायोगिक समर्थन समर्थन की योजना बनाई पोस्ट 2.3

उदाहरण और ट्यूटोरियल

यहाँ ट्यूटोरियल और उदाहरणों की एक सूची दी गई है, जो केर के साथ समाप्त होने के लिए उपरोक्त एकीकरण के अंत का वर्णन करते हैं:

  1. MirroredStrategy साथ MNIST को प्रशिक्षित करने के लिए ट्यूटोरियल
  2. MultiWorkerMirroredStrategy का उपयोग करके MNIST को प्रशिक्षित करने के लिए ट्यूटोरियल
  3. TPUStrategy का उपयोग करके प्रशिक्षण MNIST पर गाइड
  4. TensorFlow मॉडल गार्डन रिपोजिटरी जिसमें विभिन्न रणनीतियों का उपयोग करके लागू किए गए अत्याधुनिक मॉडल के संग्रह हैं।

कस्टम प्रशिक्षण छोरों के साथ tf.distribute.Strategy का उपयोग करना

आप देखा है के रूप में, का उपयोग कर tf.distribute.Strategy Keras साथ model.fit अपने कोड का केवल एक जोड़े लाइनों को बदलने की आवश्यकता है। थोड़े और प्रयास के साथ, आप कस्टम ट्रेनिंग लूप्स के साथ tf.distribute.Strategy भी उपयोग कर सकते हैं।

यदि आपको एस्टिमेटर या केरस के साथ अपने प्रशिक्षण छोरों पर अधिक लचीलेपन और नियंत्रण की आवश्यकता है, तो आप कस्टम प्रशिक्षण छोरों को लिख सकते हैं। उदाहरण के लिए, GAN का उपयोग करते समय, आप प्रत्येक राउंड में एक अलग संख्या में जनरेटर या विभेदक कदम उठाना चाह सकते हैं। इसी तरह, उच्च स्तर की रूपरेखा सुदृढीकरण सीखने के प्रशिक्षण के लिए बहुत उपयुक्त नहीं हैं।

कस्टम प्रशिक्षण छोरों का समर्थन करने के लिए, हम tf.distribute.Strategy कक्षाओं के माध्यम से तरीकों का एक मुख्य समूह प्रदान करते हैं। इनका उपयोग करने के लिए शुरू में कोड के मामूली पुनर्गठन की आवश्यकता हो सकती है, लेकिन एक बार ऐसा करने के बाद, आपको जीपीयू, टीपीयू और कई मशीनों के बीच स्विच करने में सक्षम होना चाहिए बस रणनीति उदाहरण बदलकर।

यहां हम पहले के रूप में एक ही केरस मॉडल का उपयोग करके एक सरल प्रशिक्षण उदाहरण के लिए इस उपयोग के मामले को दर्शाते हुए एक संक्षिप्त स्निपेट दिखाएंगे।

सबसे पहले, हम रणनीति के दायरे के अंदर मॉडल और ऑप्टिमाइज़र बनाते हैं। यह सुनिश्चित करता है कि मॉडल और अनुकूलक के साथ बनाए गए किसी भी चर को प्रतिबिंबित किया जा सकता है।

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 और इसे tf.distrbute.Strategy.run के पास tf.distrbute.Strategy.run साथ ही हमारे dist_dataset बनाए गए 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 प्रति उदाहरण हानि को बताता है और ग्लोबल_बैच_साइज़ द्वारा योग को विभाजित करता है। यह महत्वपूर्ण है क्योंकि बाद में के बाद ढ़ाल प्रत्येक प्रतिकृति पर गणना कर रहे हैं, वे उन्हें संक्षेप द्वारा प्रतिकृतियां में इकट्ठा कर रहे हैं।
  2. हम इस्तेमाल किया tf.distribute.Strategy.reduce द्वारा लौटाए गए परिणामों को एकत्र करने के लिए एपीआई tf.distribute.Strategy.runtf.distribute.Strategy.run रणनीति में प्रत्येक स्थानीय प्रतिकृति से परिणाम देता है, और इस परिणाम का उपभोग करने के कई तरीके हैं। आप एक समग्र मूल्य प्राप्त करने के लिए उन्हें reduce कर सकते हैं। आप परिणाम में निहित मूल्यों की सूची प्राप्त करने के लिए tf.distribute.Strategy.experimental_local_results भी कर सकते हैं, प्रति स्थानीय प्रतिकृति एक।
  3. जब apply_gradients को वितरण रणनीति के दायरे में बुलाया जाता है, तो इसका व्यवहार संशोधित होता है। विशेष रूप से, सिंक्रोनस प्रशिक्षण के दौरान प्रत्येक समानांतर उदाहरण पर ग्रेडिएंट लागू करने से पहले, यह ग्रेडिएंट्स का एक सम-ओवर-ऑल-प्रतिकृतियां करता है।

अंत में, एक बार जब हमने प्रशिक्षण कदम को परिभाषित कर लिया है, तो हम dist_dataset पर पुनरावृति कर सकते हैं और प्रशिक्षण को लूप में चला सकते हैं:

for dist_inputs in dist_dataset:
  print(distributed_train_step(dist_inputs))
tf.Tensor(0.3262986, shape=(), dtype=float32)
tf.Tensor(0.32475147, shape=(), dtype=float32)
tf.Tensor(0.3232167, shape=(), dtype=float32)
tf.Tensor(0.32169423, shape=(), dtype=float32)
tf.Tensor(0.32018384, shape=(), dtype=float32)
tf.Tensor(0.3186855, shape=(), dtype=float32)
tf.Tensor(0.317199, shape=(), dtype=float32)
tf.Tensor(0.31572425, shape=(), dtype=float32)
tf.Tensor(0.31426117, shape=(), dtype=float32)
tf.Tensor(0.31280956, shape=(), dtype=float32)
tf.Tensor(0.3113694, shape=(), dtype=float32)
tf.Tensor(0.30994043, shape=(), dtype=float32)
tf.Tensor(0.30852267, shape=(), dtype=float32)
tf.Tensor(0.30711594, shape=(), dtype=float32)
tf.Tensor(0.30572012, shape=(), dtype=float32)
tf.Tensor(0.30433518, shape=(), dtype=float32)
tf.Tensor(0.3029609, shape=(), dtype=float32)
tf.Tensor(0.30159724, shape=(), dtype=float32)
tf.Tensor(0.30024406, shape=(), dtype=float32)
tf.Tensor(0.29890123, shape=(), dtype=float32)

ऊपर के उदाहरण में, हमने आपके प्रशिक्षण के लिए इनपुट प्रदान करने के लिए dist_dataset पर पुनरावृति की। हम यह भी प्रदान करते हैं कि tf.distribute.Strategy.make_experimental_numpy_dataset सुन्न इनपुट का समर्थन करता है। tf.distribute.Strategy.experimental_distribute_dataset कॉल करने से पहले डेटासेट बनाने के लिए आप इस API का उपयोग कर सकते हैं।

अपने डेटा पर पुनरावृत्ति का दूसरा तरीका स्पष्ट रूप से पुनरावृत्तियों का उपयोग करना है। जब आप संपूर्ण डेटासेट पर चलने के विपरीत दिए गए चरणों की संख्या के लिए चलना चाहते हैं, तो आप ऐसा करना चाह सकते हैं। उपरोक्त पुनरावृत्ति को अब एक इट्रेटर बनाने के लिए संशोधित किया जाएगा और फिर इनपुट डेटा प्राप्त करने के लिए स्पष्ट रूप से इसके next कॉल करें।

iterator = iter(dist_dataset)
for _ in range(10):
  print(distributed_train_step(next(iterator)))
tf.Tensor(0.2975687, shape=(), dtype=float32)
tf.Tensor(0.2962464, shape=(), dtype=float32)
tf.Tensor(0.29493415, shape=(), dtype=float32)
tf.Tensor(0.29363185, shape=(), dtype=float32)
tf.Tensor(0.2923394, shape=(), dtype=float32)
tf.Tensor(0.29105672, shape=(), dtype=float32)
tf.Tensor(0.28978375, shape=(), dtype=float32)
tf.Tensor(0.28852034, shape=(), dtype=float32)
tf.Tensor(0.2872664, shape=(), dtype=float32)
tf.Tensor(0.28602186, shape=(), dtype=float32)

यह कस्टम प्रशिक्षण छोरों को वितरित करने के लिए tf.distribute.Strategy API का उपयोग करने का सबसे सरल मामला शामिल है। हम इन एपीआई को बेहतर बनाने की प्रक्रिया में हैं। चूंकि इस उपयोग के मामले में आपके कोड को अनुकूलित करने के लिए अधिक कार्य की आवश्यकता होती है, इसलिए हम भविष्य में एक अलग विस्तृत मार्गदर्शिका प्रकाशित करेंगे।

अब क्या समर्थित है?

प्रशिक्षण एपीआई MirroredStrategy TPUStrategy MultiWorkerMirroredStrategy CentralStorageStrategy ParameterServerStrategy
कस्टम प्रशिक्षण लूप समर्थित समर्थित प्रायोगिक समर्थन प्रायोगिक समर्थन समर्थन योजना 2.3 पोस्ट की गई

उदाहरण और ट्यूटोरियल

कस्टम प्रशिक्षण छोरों के साथ वितरण रणनीति का उपयोग करने के लिए कुछ उदाहरण यहां दिए गए हैं:

  1. MirroredStrategy लिए ट्यूटोरियल ट्रेनरस्ट्रीमटेगी का उपयोग कर।
  2. TPUStrategy का उपयोग करके प्रशिक्षण MNIST पर गाइड
  3. TensorFlow मॉडल गार्डन रिपॉजिटरी जिसमें विभिन्न रणनीतियों का उपयोग करके लागू किए गए अत्याधुनिक मॉडल के संग्रह हैं।

एस्टीमेटर (सीमित समर्थन) के साथ tf.distribute.Strategy का उपयोग करना

tf.estimator एक वितरित प्रशिक्षण TensorFlow API है जो मूल रूप से async पैरामीटर सर्वर दृष्टिकोण का समर्थन करता है। tf.distribute.Strategy तरह, हमने tf.distribute.Strategy को tf.Estimator में एकीकृत किया है। यदि आप अपने प्रशिक्षण के लिए एस्टीमेटर का उपयोग कर रहे हैं, तो आप आसानी से वितरित प्रशिक्षण को अपने कोड में बहुत कम परिवर्तनों के साथ बदल सकते हैं। इसके साथ, एस्टिमेटर उपयोगकर्ता अब कई जीपीयू और कई श्रमिकों पर सिंक्रोनस वितरित प्रशिक्षण कर सकते हैं, साथ ही टीपीयू का उपयोग कर सकते हैं। हालांकि, एस्टिमेटर में यह समर्थन सीमित है। अधिक विवरण के लिए नीचे दिए गए अब समर्थित अनुभाग देखें।

एस्टीमेटर के साथ tf.distribute.Strategy का उपयोग tf.distribute.Strategy केस से थोड़ा अलग है। strategy.scope का उपयोग करने के बजाय, अब हम RunConfig लिए RunConfig में रणनीति ऑब्जेक्ट पास करते हैं।

यहाँ कोड का एक टुकड़ा है कि एक premade अनुमानक की सहायता से पता चलता है इस LinearRegressor और MirroredStrategy :

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/tmpbnyibny6
INFO:tensorflow:Using config: {'_model_dir': '/tmp/tmpbnyibny6', '_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 0x7f8dd83bc518>, '_device_fn': None, '_protocol': None, '_eval_distribute': <tensorflow.python.distribute.mirrored_strategy.MirroredStrategy object at 0x7f8dd83bc518>, '_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 यह निर्धारित करते हैं कि मूल्यांकन कैसे वितरित किया जाएगा। यह केरस से एक और अंतर है जहां हम प्रशिक्षण और eval दोनों के लिए समान रणनीति का उपयोग करते हैं।

अब हम एक इनपुट फ़ंक्शन के साथ इस एस्टिमेटर को प्रशिक्षित और मूल्यांकन कर सकते हैं:

५५ ९ ३ कैडेडिया
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 0x7f8dd8317ea0> 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 0x7f8dd8317ea0> 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/tmpbnyibny6/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/tmpbnyibny6/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 0x7f8dd83c6730> 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 0x7f8dd83c6730> 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-09-10T01:28:07Z
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from /tmp/tmpbnyibny6/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.24097s
INFO:tensorflow:Finished evaluation at 2020-09-10-01:28:07
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/tmpbnyibny6/model.ckpt-10

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

एस्टिमेटर और केरस के बीच यहां हाइलाइट करने के लिए एक और अंतर इनपुट हैंडलिंग है। केरस में, हमने बताया कि डेटासेट के प्रत्येक बैच को कई प्रतिकृतियों में स्वचालित रूप से विभाजित किया गया है। एस्टिमेटर में, हालांकि, हम बैच के स्वचालित विभाजन नहीं करते हैं, और न ही विभिन्न श्रमिकों के डेटा को स्वचालित रूप से साझा करते हैं। आपका पूरा नियंत्रण है कि आप अपने डेटा को श्रमिकों और उपकरणों में कैसे वितरित करना चाहते हैं, और आपको अपने डेटा को कैसे वितरित करना है यह निर्दिष्ट करने के लिए एक input_fn प्रदान करना होगा।

आपके input_fn को एक बार प्रति कार्यकर्ता कहा जाता है, इस प्रकार प्रति कार्यकर्ता एक डेटासेट दिया जाता है। फिर उस कार्यकर्ता के एक बैच को उस कार्यकर्ता पर एक प्रतिकृति खिलाया जाता है, जिससे 1 कार्यकर्ता पर एन प्रतिकृतियों के लिए एन बैचों की खपत होती है। दूसरे शब्दों में, डाटासेट द्वारा दिया input_fn आकार के बैच प्रदान करना चाहिए PER_REPLICA_BATCH_SIZE । और एक कदम के लिए वैश्विक बैच आकार PER_REPLICA_BATCH_SIZE * strategy.num_replicas_in_sync रूप में प्राप्त किया जा सकता है।

मल्टी कार्यकर्ता प्रशिक्षण करते समय, आपको या तो श्रमिकों के बीच अपने डेटा को विभाजित करना चाहिए, या प्रत्येक पर एक यादृच्छिक बीज के साथ फेरबदल करना चाहिए। आप अनुमान लगा सकते हैं कि मल्टी-वर्कर ट्रेनिंग में एस्टिमेटर के साथ यह कैसे किया जाता है।

और इसी तरह, आप मल्टी वर्कर और पैरामीटर सर्वर रणनीतियों का भी उपयोग कर सकते हैं। कोड समान रहता है, लेकिन आपको अपने क्लस्टर में चल रहे प्रत्येक बाइनरी के लिए TF_CONFIG tf.estimator.train_and_evaluate , और TF_CONFIG पर्यावरण चर सेट करने की आवश्यकता है।

अब क्या समर्थित है?

TPUStrategy को छोड़कर सभी रणनीतियों का उपयोग करके एस्टिमेटर के साथ प्रशिक्षण के लिए सीमित समर्थन है। बुनियादी प्रशिक्षण और मूल्यांकन काम करना चाहिए, लेकिन कई उन्नत सुविधाएँ जैसे मचान अभी तक काम नहीं करती हैं। इस एकीकरण में कई बग भी हो सकते हैं। इस समय, हम इस समर्थन को सक्रिय रूप से सुधारने की योजना नहीं बनाते हैं, और इसके बजाय केर और कस्टम प्रशिक्षण लूप समर्थन पर ध्यान केंद्रित करते हैं। यदि संभव हो तो, आपको उन API के बजाय tf.distribute का उपयोग करना पसंद करना चाहिए।

प्रशिक्षण एपीआई MirroredStrategy TPUStrategy MultiWorkerMirroredStrategy CentralStorageStrategy ParameterServerStrategy
अनुमानक एपीआई सीमित समर्थन समर्थित नहीं सीमित समर्थन सीमित समर्थन सीमित समर्थन

उदाहरण और ट्यूटोरियल

यहां कुछ उदाहरण दिए गए हैं जो अनुमानक के साथ विभिन्न रणनीतियों के उपयोग को समाप्त करने के लिए दिखाते हैं:

  1. मल्टी-वर्कर प्रशिक्षण MultiWorkerMirroredStrategy साथ कई श्रमिकों के साथ MNIST को प्रशिक्षित करने के लिए।
  2. कुबेरनेट टेम्प्लेट का उपयोग करके टेंसरफ़्लो / इकोसिस्टम में मल्टी वर्कर प्रशिक्षण के लिए उदाहरण के लिए अंत । यह उदाहरण एक केरस मॉडल से शुरू होता है और इसे tf.keras.estimator.model_to_estimator API का उपयोग करके एक अनुमानक में tf.keras.estimator.model_to_estimator है।
  3. आधिकारिक ResNet50 मॉडल है, जो या तो का उपयोग कर प्रशिक्षित किया जा सकता MirroredStrategy या MultiWorkerMirroredStrategy

अन्य विषय

इस अनुभाग में, हम कुछ विषयों को कवर करेंगे जो कई उपयोग मामलों के लिए प्रासंगिक हैं।

TF_CONFIG पर्यावरण चर की स्थापना

बहु-कार्यकर्ता प्रशिक्षण के लिए, जैसा कि पहले उल्लेख किया गया है, आपको अपने क्लस्टर में चल रहे प्रत्येक बाइनरी के लिए TF_CONFIG पर्यावरण चर सेट करने की आवश्यकता है। TF_CONFIG पर्यावरण चर एक JSON स्ट्रिंग है जो निर्दिष्ट करता है कि कौन से कार्य क्लस्टर का गठन करते हैं, उनके पते और क्लस्टर में प्रत्येक कार्य की भूमिका। हम टेंसरफ़्लो / इकोसिस्टम रेपो में एक कुबेरनेट टेम्पलेट प्रदान करते हैं जो आपके प्रशिक्षण कार्यों के लिए 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 निर्दिष्ट करता है कि अपने मेजबानों और बंदरगाहों के साथ क्लस्टर में तीन श्रमिक और दो पीएस कार्य हैं। "कार्य" भाग निर्दिष्ट करता है कि क्लस्टर में वर्तमान कार्य की भूमिका, कार्यकर्ता 1 (दूसरा कार्यकर्ता)। एक क्लस्टर में वैध भूमिकाएं "प्रमुख", "कार्यकर्ता", "पीएस" और "मूल्यांकनकर्ता" हैं। tf.distribute.experimental.ParameterServerStrategy का उपयोग करने के अलावा कोई "ps" कार्य नहीं होना चाहिए।

आगे क्या होगा?

tf.distribute.Strategy सक्रिय रूप से विकास के अंतर्गत है। हम GitHub मुद्दों का उपयोग कर इसे प्रदान करने और आपकी प्रतिक्रिया देने के लिए आपका स्वागत करते हैं