7 दिसंबर को महिला एमएल संगोष्ठी में भाग लें अभी पंजीकरण करें

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

संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.

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

अवलोकन

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

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

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

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

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

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

इस गाइड में, आप विभिन्न प्रकार की रणनीतियों के बारे में जानेंगे और विभिन्न परिस्थितियों में आप उनका उपयोग कैसे कर सकते हैं। प्रदर्शन समस्याओं को डीबग करने का तरीका जानने के लिए, ऑप्टिमाइज़ TensorFlow GPU प्रदर्शन मार्गदर्शिका देखें।

TensorFlow सेट करें

import tensorflow as tf

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

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

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

इन उपयोग के मामलों का समर्थन करने के लिए, TensorFlow में MirroredStrategy , TPUStrategy , MultiWorkerMirroredStrategy , ParameterServerStrategy , CentralStorageStrategy और साथ ही अन्य रणनीतियाँ उपलब्ध हैं। अगला खंड बताता है कि इनमें से कौन TensorFlow में किन परिदृश्यों में समर्थित है। यहाँ एक त्वरित सिंहावलोकन है:

प्रशिक्षण एपीआई MirroredStrategy TPUStrategy MultiWorkerMirroredStrategy CentralStorageStrategy ParameterServerStrategy
Model.fit समर्थित समर्थित समर्थित प्रायोगिक समर्थन प्रायोगिक समर्थन
कस्टम प्रशिक्षण लूप समर्थित समर्थित समर्थित प्रायोगिक समर्थन प्रायोगिक समर्थन
अनुमानक एपीआई सीमित समर्थन समर्थित नहीं सीमित समर्थन सीमित समर्थन सीमित समर्थन

प्रतिबिंबित रणनीति

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

यदि आप क्रॉस डिवाइस संचार को ओवरराइड करना चाहते हैं, तो आप tf.distribute.CrossDeviceOps के उदाहरण की आपूर्ति करके cross_device_ops तर्क का उपयोग करके ऐसा कर सकते हैं। वर्तमान में, 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',)

टीपीयूरणनीति

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

वितरित प्रशिक्षण वास्तुकला के संदर्भ में, TPUStrategy एक ही MirroredStrategy है-यह सिंक्रोनस वितरित प्रशिक्षण को लागू करता है। टीपीयू कई टीपीयू कोर में कुशल ऑल-रिड्यूस और अन्य सामूहिक संचालन का अपना कार्यान्वयन प्रदान करते हैं, जिनका उपयोग 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 में, आपको इसके लिए कोई तर्क निर्दिष्ट करने की आवश्यकता नहीं है।

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

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

MultiWorkerप्रतिबिंबित रणनीति

tf.distribute.MultiWorkerMirroredStrategy बहुत हद तक MirroredStrategy से मिलती-जुलती है. यह कई श्रमिकों में तुल्यकालिक वितरित प्रशिक्षण को लागू करता है, प्रत्येक संभावित रूप से कई GPU के साथ। 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- आधारित है और CPU और GPU दोनों का समर्थन करता है। CommunicationImplementation.NCCL कार्यान्वयन। एनसीसीएल एनसीसीएल का उपयोग करता है और जीपीयू पर अत्याधुनिक प्रदर्शन प्रदान करता है लेकिन यह सीपीयू का समर्थन नहीं करता है। CollectiveCommunication.AUTO कम्युनिकेशन। ऑटो टेंसरफ्लो के लिए पसंद को टाल देता है। आप उन्हें निम्न तरीके से निर्दिष्ट कर सकते हैं:

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

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

MultiWorkerMirroredStrategy के बारे में अधिक जानकारी के लिए, निम्नलिखित ट्यूटोरियल पर विचार करें:

पैरामीटरसर्वररणनीति

कई मशीनों पर मॉडल प्रशिक्षण को बढ़ाने के लिए पैरामीटर सर्वर प्रशिक्षण एक सामान्य डेटा-समानांतर विधि है। एक पैरामीटर सर्वर प्रशिक्षण क्लस्टर में कार्यकर्ता और पैरामीटर सर्वर होते हैं। चर पैरामीटर सर्वर पर बनाए जाते हैं और उन्हें प्रत्येक चरण में श्रमिकों द्वारा पढ़ा और अद्यतन किया जाता है। विवरण के लिए पैरामीटर सर्वर प्रशिक्षण ट्यूटोरियल देखें।

TensorFlow 2 में, पैरामीटर सर्वर प्रशिक्षण tf.distribute.experimental.coordinator.ClusterCoordinator वर्ग के माध्यम से एक केंद्रीय समन्वयक-आधारित वास्तुकला का उपयोग करता है।

इस कार्यान्वयन में, worker और parameter server कार्य tf.distribute.Server s चलाते हैं जो समन्वयक के कार्यों को सुनते हैं। समन्वयक संसाधन बनाता है, प्रशिक्षण कार्यों को भेजता है, चौकियों को लिखता है, और कार्य विफलताओं से निपटता है।

समन्वयक पर चल रहे प्रोग्रामिंग में, आप एक प्रशिक्षण चरण को परिभाषित करने के लिए एक 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 केवल tf.compat.v1.distribute.experimental.ParameterServerStrategy प्रतीक के माध्यम से एक अनुमानक के साथ उपलब्ध है।

केंद्रीय भंडारण रणनीति

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

अन्य रणनीतियाँ

उपरोक्त रणनीतियों के अलावा, दो अन्य रणनीतियाँ हैं जो tf.distribute .वितरित एपीआई का उपयोग करते समय प्रोटोटाइप और डिबगिंग के लिए उपयोगी हो सकती हैं।

डिफ़ॉल्ट रणनीति

डिफ़ॉल्ट रणनीति एक वितरण रणनीति है जो तब मौजूद होती है जब कोई स्पष्ट वितरण रणनीति दायरे में नहीं होती है। यह tf.distribute.Strategy इंटरफ़ेस को लागू करता है लेकिन एक पास-थ्रू है और कोई वास्तविक वितरण प्रदान नहीं करता है। उदाहरण के लिए, Strategy.run(fn) बस fn को कॉल करेगा। इस रणनीति का उपयोग करते हुए लिखे गए कोड को बिना किसी रणनीति के लिखे गए कोड के समान व्यवहार करना चाहिए। आप इसे "नो-ऑप" रणनीति के रूप में सोच सकते हैं।

डिफ़ॉल्ट रणनीति एक सिंगलटन है- और कोई इसके अधिक उदाहरण नहीं बना सकता है। इसे किसी भी स्पष्ट रणनीति के दायरे के बाहर tf.distribute.get_strategy का उपयोग करके प्राप्त किया जा सकता है (वही एपीआई जिसका उपयोग किसी स्पष्ट रणनीति के दायरे में वर्तमान रणनीति प्राप्त करने के लिए किया जा सकता है)।

default_strategy = tf.distribute.get_strategy()

यह रणनीति दो मुख्य उद्देश्यों को पूरा करती है:

  • यह बिना शर्त वितरण-जागरूक पुस्तकालय कोड लिखने की अनुमति देता है। उदाहरण के लिए, tf.optimizer s में आप tf.distribute.get_strategy का उपयोग कर सकते हैं और ग्रेडिएंट को कम करने के लिए उस रणनीति का उपयोग कर सकते हैं—यह हमेशा एक रणनीति ऑब्जेक्ट लौटाएगा जिस पर आप Strategy.reduce 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 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>
}

वनडिवाइस रणनीति

tf.distribute.OneDeviceStrategy सभी चर और गणना को एक निर्दिष्ट डिवाइस पर रखने की एक रणनीति है।

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

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

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

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

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

केरस मॉडल के साथ tf.वितरण.रणनीति का उपयोग करें।फिट

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

यहां बताया गया है कि आपको अपने कोड में क्या बदलना है:

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

TensorFlow वितरण रणनीतियाँ सभी प्रकार के 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 का उपयोग करता है, इसलिए आप इसे कई GPU वाली मशीन पर चला सकते हैं। रणनीति.स्कोप strategy.scope() केरस को इंगित करता है कि प्रशिक्षण को वितरित करने के लिए किस रणनीति का उपयोग करना है। इस दायरे में मॉडल/ऑप्टिमाइज़र/मैट्रिक्स बनाना आपको नियमित चर के बजाय वितरित चर बनाने की अनुमति देता है। एक बार यह सेट हो जाने के बाद, आप अपने मॉडल को सामान्य रूप से फिट कर सकते हैं। MirroredStrategy उपलब्ध जीपीयू, एग्रीगेटिंग ग्रेडिएंट्स, और बहुत कुछ पर मॉडल के प्रशिक्षण को दोहराने का ख्याल रखता है।

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

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

प्रशिक्षण एपीआई MirroredStrategy TPUStrategy MultiWorkerMirroredStrategy ParameterServerStrategy CentralStorageStrategy
Model.fit समर्थित समर्थित समर्थित प्रायोगिक समर्थन प्रायोगिक समर्थन

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

यहाँ ट्यूटोरियल और उदाहरणों की एक सूची है जो उपरोक्त एकीकरण को Model.fit के साथ एंड-टू-एंड दर्शाती है:

  1. ट्यूटोरियल : Model.fit और MirroredStrategy के साथ प्रशिक्षण।
  2. ट्यूटोरियल : Model.fit और MultiWorkerMirroredStrategy के साथ प्रशिक्षण।
  3. गाइड : इसमें Model.fit और TPUStrategy का उपयोग करने का एक उदाहरण है।
  4. ट्यूटोरियल : Model.fit और ParameterServerStrategy के साथ पैरामीटर सर्वर प्रशिक्षण।
  5. ट्यूटोरियल : Model.fit और TPUStrategy के साथ GLUE बेंचमार्क से कई कार्यों के लिए BERT को फाइन-ट्यूनिंग।
  6. TensorFlow मॉडल गार्डन रिपॉजिटरी जिसमें विभिन्न रणनीतियों का उपयोग करके लागू किए गए अत्याधुनिक मॉडलों का संग्रह है।

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

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

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

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

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

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

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 फ़ंक्शन में रखें और इसे पहले बनाए गए dist_dataset से प्राप्त डेटासेट इनपुट के साथ tf.distribute.Strategy.run पर पास करें:

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 पर पुनरावृति कर सकते हैं और प्रशिक्षण को लूप में चला सकते हैं:

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 पर पुनरावृति की। आपको NumPy इनपुट का समर्थन करने के लिए 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)))
35 एल10एन-प्लेसहोल्डर
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 का उपयोग करने का सबसे सरल मामला शामिल है।

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

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

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

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

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

अन्य विषय

इस खंड में कुछ विषयों को शामिल किया गया है जो एकाधिक उपयोग के मामलों के लिए प्रासंगिक हैं।

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' निर्दिष्ट करता है कि "cluster" में उनके होस्ट और पोर्ट के साथ तीन कर्मचारी और दो "ps" कार्य हैं। "task" भाग "cluster" - कार्यकर्ता 1 (दूसरा कार्यकर्ता) में वर्तमान कार्य की भूमिका को निर्दिष्ट करता है। क्लस्टर में मान्य भूमिकाएं "chief" , "worker" , "ps" और "evaluator" हैं। tf.distribute.experimental.ParameterServerStrategy का उपयोग करने के अलावा कोई "ps" कार्य नहीं होना चाहिए।

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

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