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

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

अवलोकन

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

tf.distribute.Strategy मन में इन महत्वपूर्ण लक्ष्यों के साथ डिजाइन किया गया है:

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

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

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

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

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

# Import TensorFlow
import tensorflow as tf
2021-07-14 01:23:18.251555: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudart.so.11.0

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

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

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

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

प्रशिक्षण एपीआई प्रतिबिंबित रणनीति टीपीयूरणनीति MultiWorkerप्रतिबिंबितरणनीति केंद्रीय भंडारण रणनीति पैरामीटरसर्वररणनीति
केरस एपीआई समर्थित समर्थित समर्थित प्रायोगिक समर्थन समर्थित नियोजित पोस्ट 2.4
कस्टम प्रशिक्षण लूप समर्थित समर्थित समर्थित प्रायोगिक समर्थन प्रायोगिक समर्थन
अनुमानक एपीआई सीमित समर्थन समर्थित नहीं सीमित समर्थन सीमित समर्थन सीमित समर्थन

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

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

सभी उपकरणों में चर अद्यतनों को संप्रेषित करने के लिए कुशल ऑल-रिड्यूस एल्गोरिदम का उपयोग किया जाता है। ऑल-रिड्यूस एग्रीगेट टेन्सर्स को सभी डिवाइस में जोड़कर, और उन्हें प्रत्येक डिवाइस पर उपलब्ध कराता है। यह एक फ़्यूज्ड एल्गोरिदम है जो बहुत ही कुशल है और सिंक्रनाइज़ेशन के ऊपरी हिस्से को काफी कम कर सकता है। उपकरणों के बीच उपलब्ध संचार के प्रकार के आधार पर, कई ऑल-रिड्यूस एल्गोरिदम और कार्यान्वयन उपलब्ध हैं। डिफ़ॉल्ट रूप से, यह NVIDIA सामूहिक संचार लाइब्रेरी (का उपयोग करता NCCL सभी को कम कार्यान्वयन के रूप में)। आप कुछ अन्य विकल्पों में से चुन सकते हैं या अपना खुद का लिख ​​सकते हैं।

यहाँ बनाने की सबसे सरल तरीका है MirroredStrategy :

mirrored_strategy = tf.distribute.MirroredStrategy()
WARNING:tensorflow:Collective ops is not configured at program startup. Some performance features may not be enabled.
2021-07-14 01:23:19.530023: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcuda.so.1
2021-07-14 01:23:20.213426: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-14 01:23:20.214078: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1733] Found device 0 with properties: 
pciBusID: 0000:00:05.0 name: NVIDIA Tesla V100-SXM2-16GB computeCapability: 7.0
coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s
2021-07-14 01:23:20.214108: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudart.so.11.0
2021-07-14 01:23:20.217733: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcublas.so.11
2021-07-14 01:23:20.217820: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcublasLt.so.11
2021-07-14 01:23:20.218871: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcufft.so.10
2021-07-14 01:23:20.219205: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcurand.so.10
2021-07-14 01:23:20.220324: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcusolver.so.11
2021-07-14 01:23:20.221308: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcusparse.so.11
2021-07-14 01:23:20.221482: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudnn.so.8
2021-07-14 01:23:20.221579: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-14 01:23:20.222279: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-14 01:23:20.222966: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1871] Adding visible gpu devices: 0
2021-07-14 01:23:20.224084: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX512F FMA
To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.
2021-07-14 01:23:20.224666: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-14 01:23:20.225322: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1733] Found device 0 with properties: 
pciBusID: 0000:00:05.0 name: NVIDIA Tesla V100-SXM2-16GB computeCapability: 7.0
coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s
2021-07-14 01:23:20.225396: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-14 01:23:20.226008: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-14 01:23:20.226671: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1871] Adding visible gpu devices: 0
2021-07-14 01:23:20.226715: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudart.so.11.0
2021-07-14 01:23:20.843669: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1258] Device interconnect StreamExecutor with strength 1 edge matrix:
2021-07-14 01:23:20.843707: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1264]      0 
2021-07-14 01:23:20.843716: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1277] 0:   N 
2021-07-14 01:23:20.843925: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-14 01:23:20.844616: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-14 01:23:20.845280: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-07-14 01:23:20.845985: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1418] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 14646 MB memory) -> physical GPU (device: 0, name: NVIDIA Tesla V100-SXM2-16GB, pci bus id: 0000:00:05.0, compute capability: 7.0)
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)

यह एक पैदा करेगा MirroredStrategy उदाहरण है, जो सभी GPUs कि 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
WARNING:tensorflow:Collective ops is not configured at program startup. Some performance features may not be enabled.
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())
WARNING:tensorflow:Collective ops is not configured at program startup. Some performance features may not be enabled.
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)

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

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

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

यहाँ कैसे आप का दृष्टांत होता है TPUStrategy :

cluster_resolver = tf.distribute.cluster_resolver.TPUClusterResolver(
    tpu=tpu_address)
tf.config.experimental_connect_to_cluster(cluster_resolver)
tf.tpu.experimental.initialize_tpu_system(cluster_resolver)
tpu_strategy = tf.distribute.TPUStrategy(cluster_resolver)

TPUClusterResolver उदाहरण tpus लगाने में मदद करता। Colab में, आपको इसके लिए कोई तर्क निर्दिष्ट करने की आवश्यकता नहीं है।

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

  • आप में अपने TPU संसाधन का नाम निर्दिष्ट करना होगा 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 आधारित है और दोनों CPUs और GPUs का समर्थन करता है। CommunicationImplementation.NCCL NCCL उपयोग करता है और GPUs पर राज्य के कला प्रदर्शन प्रदान करता है, लेकिन यह सीपीयू समर्थन नहीं करता। CollectiveCommunication.AUTO Tensorflow को पसंद defers। आप उन्हें निम्न तरीके से निर्दिष्ट कर सकते हैं:

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

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

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

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

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

समन्वयक पर चल रहा है प्रोग्रामिंग में, आप एक का उपयोग करेगा ParameterServerStrategy एक प्रशिक्षण कदम को परिभाषित करने के वस्तु और एक का उपयोग ClusterCoordinator दूरदराज के श्रमिकों के लिए प्रेषण प्रशिक्षण कदम। यहाँ उन्हें बनाने का सबसे सरल तरीका है:

strategy = tf.distribute.experimental.ParameterServerStrategy(
    tf.distribute.cluster_resolver.TFConfigClusterResolver(),
    variable_partitioner=variable_partitioner)
coordinator = tf.distribute.experimental.coordinator.ClusterCoordinator(
    strategy)

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 उदाहरण है, जिसमें सभी दृश्य GPUs और सीपीयू का उपयोग करेगा। वेरिएबल पर वेरिएबल के अपडेट को वेरिएबल पर लागू करने से पहले एग्रीगेट किया जाएगा।

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

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

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

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

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

default_strategy = tf.distribute.get_strategy()

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

  • यह वितरण जागरूक पुस्तकालय कोड को बिना शर्त लिखने की अनुमति देता है। उदाहरण के लिए, में tf.optimizer रों कर सकते हैं उपयोग 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 the Default Strategy
  strategy = tf.distribute.get_strategy() 

with strategy.scope():
  # Do something interesting
  print(tf.Variable(1.))
WARNING:tensorflow:Collective ops is not configured at program startup. Some performance features may not be enabled.
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.distribute.Strategy साथ tf.keras.Model.fit

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

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

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

TensorFlow वितरण रणनीतियाँ सभी प्रकार के 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')
WARNING:tensorflow:Collective ops is not configured at program startup. Some performance features may not be enabled.
INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).

इस उदाहरण का उपयोग करता है MirroredStrategy ताकि आप कई GPUs के साथ एक मशीन पर इस चला सकते हैं,। strategy.scope() Keras जो रणनीति प्रशिक्षण वितरित करने के लिए उपयोग करने के लिए करने के लिए इंगित करता है। इस दायरे में मॉडल/ऑप्टिमाइज़र/मैट्रिक्स बनाने से आप नियमित चर के बजाय वितरित चर बना सकते हैं। एक बार यह सेट हो जाने के बाद, आप अपने मॉडल को सामान्य रूप से फिट कर सकते हैं। MirroredStrategy , उपलब्ध GPUs पर मॉडल के प्रशिक्षण नकल ढ़ाल के योग, और अधिक का ख्याल रखता है।

dataset = tf.data.Dataset.from_tensors(([1.], [1.])).repeat(100).batch(10)
model.fit(dataset, epochs=2)
model.evaluate(dataset)
Epoch 1/2
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
INFO:tensorflow:Reduce to /job:localhost/replica:0/task:0/device:CPU:0 then broadcast to ('/job:localhost/replica:0/task:0/device:CPU:0',).
2021-07-14 01:23:21.641884: 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
        }
      }
    }
  }
}

2021-07-14 01:23:21.671942: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:176] None of the MLIR Optimization Passes are enabled (registered 2)
2021-07-14 01:23:21.672424: I tensorflow/core/platform/profile_utils/cpu_utils.cc:114] CPU Frequency: 2000175000 Hz
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-07-14 01:23:24.013985: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcublas.so.11
10/10 [==============================] - 3s 2ms/step - loss: 0.0014
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: 6.3687e-04
2021-07-14 01:23:24.434928: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcublasLt.so.11
2021-07-14 01:23:24.528027: 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: 3.9551e-04
0.00039551049121655524

यहाँ एक 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-07-14 01:23:25.775102: 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_1006"
    }
  }
}
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: 2.8150e-04
Epoch 2/2
10/10 [==============================] - 0s 2ms/step - loss: 1.2442e-04
<tensorflow.python.keras.callbacks.History at 0x7fe091028f50>

दोनों ही मामलों-साथ में Dataset या Numpy-प्रत्येक दिए गए इनपुट के बैच कई प्रतिकृतियां के बीच समान रूप से विभाजित है। उदाहरण के लिए, यदि आप उपयोग कर रहे हैं MirroredStrategy 2 GPUs के साथ, आकार 10 में से प्रत्येक बैच 2 GPUs के बीच प्रत्येक चरण में प्रत्येक प्राप्त 5 इनपुट उदाहरण के साथ विभाजित हो जाएगी। जैसे ही आप अधिक 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]

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

प्रशिक्षण एपीआई प्रतिबिंबित रणनीति टीपीयूरणनीति MultiWorkerप्रतिबिंबितरणनीति पैरामीटरसर्वररणनीति केंद्रीय भंडारण रणनीति
केरस एपीआई समर्थित समर्थित प्रायोगिक समर्थन प्रायोगिक समर्थन प्रायोगिक समर्थन

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

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

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

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

आप देखा है के रूप में, का उपयोग कर tf.distribute.Strategy Keras साथ 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-07-14 01:23:27.005233: W tensorflow/core/grappler/optimizers/data/auto_shard.cc:695] AUTO sharding policy will apply DATA sharding policy as it failed to apply FILE sharding policy because of the following reason: Found an unshardable source dataset: name: "TensorDataset/_2"
op: "TensorDataset"
input: "Placeholder/_0"
input: "Placeholder/_1"
attr {
  key: "Toutput_types"
  value {
    list {
      type: DT_FLOAT
      type: DT_FLOAT
    }
  }
}
attr {
  key: "output_shapes"
  value {
    list {
      shape {
        dim {
          size: 1
        }
      }
      shape {
        dim {
          size: 1
        }
      }
    }
  }
}

फिर, प्रशिक्षण के एक चरण को परिभाषित करें। उपयोग tf.GradientTape गणना ढ़ाल और अनुकूलक करने के लिए अपने मॉडल के चर अद्यतन करने के लिए उन ढ़ाल लागू करने के लिए। इस प्रशिक्षण कदम वितरित करने के लिए एक समारोह में रख train_step और करने के लिए इसे पारित tf.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 द्वारा लौटाए गए परिणामों को एकत्र करने के लिए एपीआई 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.36346385, shape=(), dtype=float32)
tf.Tensor(0.3616105, shape=(), dtype=float32)
tf.Tensor(0.3597728, shape=(), dtype=float32)
tf.Tensor(0.35795057, shape=(), dtype=float32)
tf.Tensor(0.35614368, shape=(), dtype=float32)
tf.Tensor(0.35435185, shape=(), dtype=float32)
tf.Tensor(0.3525751, shape=(), dtype=float32)
tf.Tensor(0.35081312, shape=(), dtype=float32)
tf.Tensor(0.3490658, shape=(), dtype=float32)
tf.Tensor(0.34733298, shape=(), dtype=float32)
tf.Tensor(0.34561458, shape=(), dtype=float32)
tf.Tensor(0.3439103, shape=(), dtype=float32)
tf.Tensor(0.3422201, shape=(), dtype=float32)
tf.Tensor(0.34054378, shape=(), dtype=float32)
tf.Tensor(0.33888122, shape=(), dtype=float32)
tf.Tensor(0.33723223, shape=(), dtype=float32)
tf.Tensor(0.3355967, shape=(), dtype=float32)
tf.Tensor(0.3339745, shape=(), dtype=float32)
tf.Tensor(0.33236548, shape=(), dtype=float32)
tf.Tensor(0.33076945, shape=(), dtype=float32)

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

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

iterator = iter(dist_dataset)
for _ in range(10):
  print(distributed_train_step(next(iterator)))
tf.Tensor(0.3291864, shape=(), dtype=float32)
tf.Tensor(0.32761604, shape=(), dtype=float32)
tf.Tensor(0.32605836, shape=(), dtype=float32)
tf.Tensor(0.3245131, shape=(), dtype=float32)
tf.Tensor(0.32298028, shape=(), dtype=float32)
tf.Tensor(0.32145968, shape=(), dtype=float32)
tf.Tensor(0.3199512, shape=(), dtype=float32)
tf.Tensor(0.31845465, shape=(), dtype=float32)
tf.Tensor(0.31697, shape=(), dtype=float32)
tf.Tensor(0.31549713, shape=(), dtype=float32)

इस कवर का उपयोग करने का सबसे सामान्य स्थिति tf.distribute.Strategy एपीआई कस्टम प्रशिक्षण छोरों वितरित करने के लिए।

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

प्रशिक्षण एपीआई प्रतिबिंबित रणनीति टीपीयूरणनीति MultiWorkerप्रतिबिंबितरणनीति पैरामीटरसर्वररणनीति केंद्रीय भंडारण रणनीति
कस्टम प्रशिक्षण लूप समर्थित समर्थित प्रायोगिक समर्थन प्रायोगिक समर्थन प्रायोगिक समर्थन

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

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

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

अन्य विषय

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

TF_CONFIG पर्यावरण चर सेट करना

बहु कार्यकर्ता प्रशिक्षण के लिए, के रूप में पहले उल्लेख किया है, आप सेट करने की आवश्यकता TF_CONFIG अपने क्लस्टर में चल रहे प्रत्येक द्विआधारी के लिए वातावरण चर। TF_CONFIG वातावरण चर JSON स्ट्रिंग जो निर्दिष्ट करता है क्या कार्य एक समूह, उनके पते और क्लस्टर में प्रत्येक कार्य की भूमिका का गठन है। tensorflow/ecosystem रेपो एक Kubernetes टेम्पलेट, जो सेट उपलब्ध कराता है TF_CONFIG अपने प्रशिक्षण कार्यों के लिए।

वहाँ के दो घटक हैं TF_CONFIG एक क्लस्टर और एक कार्य:।

  • एक क्लस्टर प्रशिक्षण क्लस्टर के बारे में जानकारी प्रदान करता है, जो एक ऐसा निर्देश है जिसमें विभिन्न प्रकार की नौकरियां जैसे कार्यकर्ता शामिल हैं। बहु-कार्यकर्ता प्रशिक्षण में, आमतौर पर एक कार्यकर्ता होता है जो एक नियमित कार्यकर्ता के अलावा थोड़ी अधिक जिम्मेदारी लेता है जैसे कि चेकपॉइंट को सहेजना और TensorBoard के लिए सारांश फ़ाइल लिखना। इस तरह के कार्यकर्ता "प्रमुख" कार्यकर्ता के रूप में जाना जाता है, और यह प्रथागत है कि सूचकांक 0 के साथ कार्यकर्ता प्रमुख कार्यकर्ता के रूप में नियुक्त किया जाता है है (वास्तव में यह कैसे है tf.distribute.Strategy कार्यान्वित किया जाता है)।
  • दूसरी ओर एक कार्य वर्तमान कार्य की जानकारी प्रदान करता है। पहला घटक क्लस्टर सभी श्रमिकों के लिए समान है, और दूसरा घटक कार्य प्रत्येक कार्यकर्ता पर अलग है और उस कार्यकर्ता के प्रकार और सूचकांक को निर्दिष्ट करता है।

का एक उदाहरण TF_CONFIG है:

os.environ["TF_CONFIG"] = json.dumps({
    "cluster": {
        "worker": ["host1:port", "host2:port", "host3:port"],
        "ps": ["host4:port", "host5:port"]
    },
   "task": {"type": "worker", "index": 1}
})

यह TF_CONFIG निर्दिष्ट तीन कार्यकर्ताओं और दो हैं कि "ps" में कार्य "cluster" उनके मेजबानों और बंदरगाहों के साथ। "task" भाग निर्दिष्ट करता है कि में वर्तमान कार्य की भूमिका "cluster" -worker 1 (दूसरा कार्यकर्ता)। एक क्लस्टर में मान्य भूमिकाएँ हैं "chief" , "worker" , "ps" , और "evaluator" । कोई होना चाहिए "ps" का उपयोग करते समय को छोड़कर काम tf.distribute.experimental.ParameterServerStrategy

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

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