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

केरस के साथ बहु-कार्यकर्ता प्रशिक्षण

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

अवलोकन

यह ट्यूटोरियल विशेष रूप से tf.distribute.experimental.MultiWorkerMirroredStrategy API, विशेष रूप से tf.distribute.experimental.MultiWorkerMirroredStrategy का उपयोग करके tf.distribute.Strategy मॉडल के साथ बहु-वर्कर वितरित प्रशिक्षण प्रदर्शित करता है। इस रणनीति की मदद से, एक केरस मॉडल जिसे एकल-कार्यकर्ता पर चलाने के लिए डिज़ाइन किया गया था, न्यूनतम कोड परिवर्तन के साथ कई श्रमिकों पर मूल रूप से काम कर सकता है।

TensorFlow गाइड में वितरित प्रशिक्षण वितरण रणनीतियों के अवलोकन के लिए उपलब्ध है। tf.distribute.Strategy API की गहरी समझ में रुचि रखने वालों के लिए समर्थन करता है।

सेट अप

सबसे पहले, TensorFlow सेटअप और आवश्यक आयात।

 import os
import tensorflow as tf
import numpy as np
 

डेटासेट तैयार करना

अब, MNIST डाटासेट तैयार करते हैं। MNIST डेटासेट में 60,000 प्रशिक्षण उदाहरण और हस्तलिखित अंकों के 0–9 के 10,000 परीक्षण उदाहरण हैं, जिन्हें 28x28-पिक्सेल मोनोक्रोम छवियों के रूप में प्रारूपित किया गया है। इस उदाहरण में, हम डेटासेट के प्रशिक्षण भाग को प्रदर्शित करने के लिए लेंगे।

 def mnist_dataset(batch_size):
  (x_train, y_train), _ = tf.keras.datasets.mnist.load_data()
  # The `x` arrays are in uint8 and have values in the range [0, 255].
  # We need to convert them to float32 with values in the range [0, 1]
  x_train = x_train / np.float32(255)
  y_train = y_train.astype(np.int64)
  train_dataset = tf.data.Dataset.from_tensor_slices(
      (x_train, y_train)).shuffle(60000).repeat().batch(batch_size)
  return train_dataset
 

केर मॉडल का निर्माण करें

यहाँ हम अपने MNIST डेटासेट के साथ प्रशिक्षित करने के लिए एक साधारण tf.keras.Sequential नेटवर्क नेटवर्क्स केरस मॉडल के निर्माण और संकलन के लिए tf.keras.Sequential API का उपयोग करते हैं।

 def build_and_compile_cnn_model():
  model = tf.keras.Sequential([
      tf.keras.Input(shape=(28, 28)),
      tf.keras.layers.Reshape(target_shape=(28, 28, 1)),
      tf.keras.layers.Conv2D(32, 3, activation='relu'),
      tf.keras.layers.Flatten(),
      tf.keras.layers.Dense(128, activation='relu'),
      tf.keras.layers.Dense(10)
  ])
  model.compile(
      loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
      optimizer=tf.keras.optimizers.SGD(learning_rate=0.001),
      metrics=['accuracy'])
  return model
 

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

 per_worker_batch_size = 64
single_worker_dataset = mnist_dataset(per_worker_batch_size)
single_worker_model = build_and_compile_cnn_model()
single_worker_model.fit(single_worker_dataset, epochs=3, steps_per_epoch=70)
 
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 0s 0us/step
Epoch 1/3
70/70 [==============================] - 0s 2ms/step - loss: 2.2701 - accuracy: 0.2451
Epoch 2/3
70/70 [==============================] - 0s 2ms/step - loss: 2.1827 - accuracy: 0.4777
Epoch 3/3
70/70 [==============================] - 0s 2ms/step - loss: 2.0865 - accuracy: 0.5955

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

बहु-कार्यकर्ता विन्यास

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

TF_CONFIG दो घटक हैं: cluster और taskcluster प्रशिक्षण क्लस्टर के बारे में जानकारी प्रदान करता है, जो विभिन्न प्रकार की नौकरियों जैसे कि worker साथ एक worker । साथ बहु कार्यकर्ता प्रशिक्षण में MultiWorkerMirroredStrategy , वहां आम तौर पर एक है worker कि चौकी बचत और क्या एक नियमित के अलावा TensorBoard के लिए सारांश फ़ाइल लेखन की तरह एक छोटे से अधिक जिम्मेदारी लेता worker करता है। इस तरह के कार्यकर्ता के रूप में जाना जाता है chief कार्यकर्ता, और यह प्रथागत है कि worker के साथ index 0 प्रमुख के रूप में नियुक्त किया जाता है worker (वास्तव में यह कैसे है tf.distribute.Strategy कार्यान्वित किया जाता है)। task दूसरी ओर वर्तमान कार्य की जानकारी प्रदान करता है। पहला घटक cluster सभी श्रमिकों के लिए समान है, और दूसरा घटक task प्रत्येक कार्यकर्ता पर अलग है और उस कार्यकर्ता के type और index को निर्दिष्ट करता है।

इस उदाहरण में, हमने कार्य type को "worker" और कार्य index को 0 । इसका मतलब यह है कि ऐसी मशीन स्थापित करने वाला पहला श्रमिक है, जिसे मुख्य कार्यकर्ता के रूप में नियुक्त किया जाएगा और अन्य श्रमिकों की तुलना में अधिक काम करेगा। ध्यान दें कि अन्य मशीनों के लिए TF_CONFIG पर्यावरण चर के रूप में अच्छी तरह से सेट करने की आवश्यकता होगी, और इसमें एक ही cluster TF_CONFIG होना चाहिए, लेकिन उन मशीनों की भूमिका क्या index आधार पर अलग-अलग कार्य type या कार्य index

चित्रण प्रयोजनों के लिए, यह ट्यूटोरियल दिखाता है कि कोई localhost पर 2 श्रमिकों के साथ TF_CONFIG कैसे सेट कर सकता है। व्यवहार में, उपयोगकर्ता बाहरी आईपी पते / बंदरगाहों पर कई श्रमिकों का निर्माण करेंगे, और उचित रूप से प्रत्येक कार्यकर्ता पर TF_CONFIG सेट TF_CONFIG

 os.environ['TF_CONFIG'] = json.dumps({
    'cluster': {
        'worker': ["localhost:12345", "localhost:23456"]
    },
    'task': {'type': 'worker', 'index': 0}
})
 

ध्यान दें कि सीखने की दर इस उदाहरण में तय की गई है, सामान्य तौर पर यह वैश्विक बैच आकार के आधार पर सीखने की दर को समायोजित करने के लिए आवश्यक हो सकता है।

सही रणनीति चुनें

TensorFlow में, वितरित प्रशिक्षण में समकालिक प्रशिक्षण शामिल होता है, जहाँ प्रशिक्षण के चरणों को श्रमिकों और प्रतिकृतियों और अतुल्यकालिक प्रशिक्षण के बीच समन्वयित किया जाता है, जहाँ प्रशिक्षण चरणों का कड़ाई से समन्वय नहीं होता है।

MultiWorkerMirroredStrategy , जो तुल्यकालिक बहु-कार्यकर्ता प्रशिक्षण के लिए अनुशंसित रणनीति है, इस गाइड में प्रदर्शित किया जाएगा। मॉडल को प्रशिक्षित करने के लिए, tf.distribute.experimental.MultiWorkerMirroredStrategy का उपयोग करें। MultiWorkerMirroredStrategy मॉडल की परतों में सभी MultiWorkerMirroredStrategy पर सभी MultiWorkerMirroredStrategy प्रतियां सभी MultiWorkerMirroredStrategy बनाता है। यह का उपयोग करता है CollectiveOps , सामूहिक संचार के लिए एक TensorFlow सेशन, कुल ढ़ाल के लिए और सिंक में चर रखने के लिए। tf.distribute.Strategy मार्गदर्शिका में इस रणनीति के बारे में अधिक विवरण है।

 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 आर-आधारित सामूहिक को जीआरपीसी का उपयोग करके क्रॉस-होस्ट संचार परत के रूप में लागू करता है। NCCL सामूहिकता को लागू करने के लिए एनवीडिया के एनसीसीएल का उपयोग करता है। AUTO रनटाइम के लिए पसंद को धता बताता है। सामूहिक कार्यान्वयन का सबसे अच्छा विकल्प जीपीयू की संख्या और प्रकार पर निर्भर करता है, और नेटवर्क क्लस्टर में इंटरकनेक्ट करता है।

MultiWorkerMirroredStrategy के साथ मॉडल को प्रशिक्षित करें

के एकीकरण के साथ tf.distribute.Strategy में एपीआई tf.keras , केवल बदल आप वितरित करने के लिए बहु-कार्यकर्ता को प्रशिक्षण मॉडल के निर्माण और संलग्न है कर देगा model.compile() कॉल अंदर strategy.scope() । वितरण रणनीति का दायरा निर्धारित करता है कि चर कैसे और कहां बनाए जाते हैं, और MultiWorkerMirroredStrategy के मामले में, बनाए गए चर MirroredVariable किए हुए हैं, और वे प्रत्येक कार्यकर्ता पर दोहराए जाते हैं।

 num_workers = 4

# Here the batch size scales up by number of workers since 
# `tf.data.Dataset.batch` expects the global batch size. Previously we used 64, 
# and now this becomes 128.
global_batch_size = per_worker_batch_size * num_workers
multi_worker_dataset = mnist_dataset(global_batch_size)

with strategy.scope():
  # Model building/compiling need to be within `strategy.scope()`.
  multi_worker_model = build_and_compile_cnn_model()

# Keras' `model.fit()` trains the model with specified number of epochs and
# number of steps per epoch. Note that the numbers here are for demonstration
# purposes only and may not sufficiently produce a model with good quality.
multi_worker_model.fit(multi_worker_dataset, epochs=3, steps_per_epoch=70)
 
Epoch 1/3
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.
70/70 [==============================] - 0s 3ms/step - loss: 2.2682 - accuracy: 0.2265
Epoch 2/3
70/70 [==============================] - 0s 3ms/step - loss: 2.1714 - accuracy: 0.4954
Epoch 3/3
70/70 [==============================] - 0s 3ms/step - loss: 2.0638 - accuracy: 0.6232

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

डेटासट शार्डिंग और बैच साइज

मल्टी-वर्कर प्रशिक्षण में MultiWorkerMirroredStrategy साथ, अभिसरण और प्रदर्शन सुनिश्चित करने के लिए डेटासेट को MultiWorkerMirroredStrategy करना आवश्यक है। हालाँकि, ध्यान दें कि ऊपर दिए गए कोड स्निपेट में, डेटासेट को सीधे model.fit() शार्ड की आवश्यकता के बिना पास किया जाता है; इसका कारण यह है कि tf.distribute.Strategy API स्वतः डेटासेट के tf.distribute.Strategy का ध्यान रखता है। यह फ़ाइल स्तर पर डेटासेट्स को शार्प करता है जो कि तिरछी धारियां बना सकता है। चरम मामलों में जहां केवल एक फ़ाइल होती है, केवल पहले शार्क (यानी कार्यकर्ता) को प्रशिक्षण या मूल्यांकन डेटा मिलेगा और परिणामस्वरूप सभी श्रमिकों को त्रुटियां मिलेंगी।

यदि आप अपने प्रशिक्षण के लिए मैन्युअल शार्डिंग पसंद करते हैं, तो tf.data.experimental.DistributeOptions api के माध्यम से tf.data.experimental.DistributeOptions बंद किया जा सकता है। वस्तुतः,

 options = tf.data.Options()
options.experimental_distribute.auto_shard_policy = tf.data.experimental.AutoShardPolicy.OFF
dataset_no_auto_shard = multi_worker_dataset.with_options(options)
 

ध्यान देने योग्य बात यह है कि datasets लिए बैच आकार है। ऊपर दिए गए कोड स्निपेट में, हम global_batch_size = per_worker_batch_size * num_workers उपयोग करते हैं, जो num_workers बार है, क्योंकि यह एकल कर्मचारी के लिए बहुत बड़ा है, क्योंकि प्रति बैच बैच का आकार प्रभावी है बैच आकार ( tf.data.Dataset.batch() में पारित पैरामीटर) tf.data.Dataset.batch() ) श्रमिकों की संख्या से विभाजित है, और इस परिवर्तन के साथ हम प्रति कार्यकर्ता बैच आकार पहले की तरह ही रख रहे हैं।

मूल्यांकन

यदि आप validation_data को model.fit में पास करते हैं, तो यह प्रत्येक युग के लिए प्रशिक्षण और मूल्यांकन के बीच वैकल्पिक होगा। मूल्यांकन लेने validation_data सभी श्रमिकों के लिए कार्यकर्ताओं के एक ही सेट भर में वितरित किया जाता है और मूल्यांकन परिणाम एकत्रित कर रहे हैं और उपलब्ध नहीं हैं। प्रशिक्षण के समान, सत्यापन डेटासेट स्वचालित रूप से फ़ाइल स्तर पर तेज होता है। आपको सत्यापन डेटासेट में एक वैश्विक बैच आकार सेट validation_steps और सत्यापन_स्टेप सेट validation_steps । मूल्यांकन के लिए एक दोहराया डेटासेट की भी सिफारिश की जाती है।

वैकल्पिक रूप से, आप एक और कार्य भी बना सकते हैं जो समय-समय पर चौकियों को पढ़ता है और मूल्यांकन चलाता है। ऐसा एस्टिमेटर करता है। लेकिन यह मूल्यांकन करने का एक अनुशंसित तरीका नहीं है और इस प्रकार इसके विवरण को छोड़ दिया जाता है।

भविष्यवाणी

वर्तमान में model.predict साथ काम नहीं करता है MultiWorkerMirroredStrategy.

प्रदर्शन

अब आपके पास एक केरस मॉडल है जो MultiWorkerMirroredStrategy साथ कई श्रमिकों में चलाने के लिए MultiWorkerMirroredStrategy । आप MultiWorkerMirroredStrategy ट्रेनिंग के मल्टी-वर्कर प्रशिक्षण के प्रदर्शन को निम्न तकनीकों से MultiWorkerMirroredStrategy

  • MultiWorkerMirroredStrategy कई सामूहिक संचार कार्यान्वयन प्रदान करता है। RING आर-आधारित सामूहिक जीआरपीसी का उपयोग करके क्रॉस-होस्ट संचार परत के रूप में लागू करता है। NCCL सामूहिकता को लागू करने के लिए एनवीडिया के एनसीसीएल का उपयोग करता है। AUTO रनटाइम के लिए पसंद को धता बताता है। सामूहिक कार्यान्वयन का सबसे अच्छा विकल्प जीपीयू की संख्या और प्रकार पर निर्भर करता है, और नेटवर्क क्लस्टर में इंटरकनेक्ट करता है। स्वचालित पसंद को ओवरराइड करने के लिए, MultiWorkerMirroredStrategy के MultiWorkerMirroredStrategy के communication पैरामीटर के लिए एक मान्य मान निर्दिष्ट करें, जैसे communication=tf.distribute.experimental.CollectiveCommunication.NCCL
  • यदि संभव हो तो tf.float चर कास्ट करें। आधिकारिक ResNet मॉडल में इसका एक उदाहरण शामिल है कि यह कैसे किया जा सकता है।

दोष सहिष्णुता

समकालिक प्रशिक्षण में, क्लस्टर विफल हो जाता है यदि कोई कार्यकर्ता विफल हो जाता है और कोई विफलता-पुनर्प्राप्ति तंत्र मौजूद नहीं है। tf.distribute.Strategy का उपयोग tf.distribute.Strategy के साथ करने से उन मामलों में दोष सहिष्णुता का लाभ मिलता है जहां कार्यकर्ता मर जाते हैं या अन्यथा अस्थिर होते हैं। हम आपकी पसंद की वितरित फ़ाइल प्रणाली में प्रशिक्षण राज्य को संरक्षित करके ऐसा करते हैं, जैसे कि उस उदाहरण के पुनरारंभ होने पर जो पहले विफल हो गया था या छूट गया था, प्रशिक्षण राज्य को पुनर्प्राप्त किया जाता है।

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

ModelCheckpoint कॉलबैक

ModelCheckpoint कॉलबैक अब दोष सहिष्णुता कार्यक्षमता प्रदान नहीं करता है, कृपया इसके बजाय BackupAndRestore कॉलबैक का उपयोग करें।

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

मॉडल की बचत और लोडिंग

अपने मॉडल का उपयोग कर बचाने के लिए model.save या tf.saved_model.save , जरूरतों को बचाने के लिए गंतव्य प्रत्येक कार्यकर्ता के लिए अलग अलग हो सकता है। गैर-मुख्य श्रमिकों पर, आपको मॉडल को एक अस्थायी निर्देशिका में सहेजने की आवश्यकता होगी, और प्रमुख पर, आपको प्रदान की गई मॉडल निर्देशिका को सहेजना होगा। एक ही स्थान पर लिखने की कोशिश कर रहे कई श्रमिकों से उत्पन्न त्रुटियों को रोकने के लिए कार्यकर्ता पर अस्थायी निर्देशिकाओं को अद्वितीय बनाने की आवश्यकता है। सभी निर्देशिकाओं में सहेजा गया मॉडल समान है और आमतौर पर केवल प्रमुख द्वारा सहेजे गए मॉडल को पुनर्स्थापित या सेवा के लिए संदर्भित किया जाना चाहिए। हमारा सुझाव है कि आपके पास कुछ सफाई तर्क हैं जो आपके प्रशिक्षण पूरा होने के बाद श्रमिकों द्वारा बनाई गई अस्थायी निर्देशिकाओं को हटा देते हैं।

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

MultiWorkerMirroredStrategy साथ, कार्यक्रम प्रत्येक कार्यकर्ता पर चलाया जाता है, और यह जानने के लिए कि वर्तमान कार्यकर्ता प्रमुख है, हम क्लस्टर रिज़ॉल्वर ऑब्जेक्ट का लाभ उठाते हैं, जिसमें task_type और task_id विशेषताएँ हैं। task_type आपको बताता है कि वर्तमान नौकरी क्या है (जैसे 'कार्यकर्ता'), और task_id आपको कार्यकर्ता की पहचानकर्ता बताता है। आईडी 0 वाले कार्यकर्ता को मुख्य कार्यकर्ता के रूप में नामित किया गया है।

नीचे दिए गए कोड स्निपेट में, write_filepath लिखने के लिए फ़ाइल पथ प्रदान करता है, जो कि कार्यकर्ता आईडी पर निर्भर करता है। प्रमुख (आईडी 0 के साथ कार्यकर्ता) के मामले में, यह मूल फ़ाइल पथ को लिखता है; दूसरों के लिए, यह लिखने के लिए एक अस्थायी निर्देशिका (निर्देशिका पथ में आईडी के साथ) बनाता है:

 model_path = '/tmp/keras-model'

def _is_chief(task_type, task_id):
  # If `task_type` is None, this may be operating as single worker, which works 
  # effectively as chief.
  return task_type is None or task_type == 'chief' or (
            task_type == 'worker' and task_id == 0)

def _get_temp_dir(dirpath, task_id):
  base_dirpath = 'workertemp_' + str(task_id)
  temp_dir = os.path.join(dirpath, base_dirpath)
  tf.io.gfile.makedirs(temp_dir)
  return temp_dir

def write_filepath(filepath, task_type, task_id):
  dirpath = os.path.dirname(filepath)
  base = os.path.basename(filepath)
  if not _is_chief(task_type, task_id):
    dirpath = _get_temp_dir(dirpath, task_id)
  return os.path.join(dirpath, base)

task_type, task_id = (strategy.cluster_resolver.task_type,
                      strategy.cluster_resolver.task_id)
write_model_path = write_filepath(model_path, task_type, task_id)
 

इसके साथ, आप अब सहेजने के लिए तैयार हैं:

 multi_worker_model.save(write_model_path)
 
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Model.state_updates (from tensorflow.python.keras.engine.training) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
WARNING:tensorflow:From /tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/training/tracking/tracking.py:111: Layer.updates (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version.
Instructions for updating:
This property should not be used in TensorFlow 2.0, as updates are applied automatically.
INFO:tensorflow:Assets written to: /tmp/keras-model/assets

जैसा कि हमने ऊपर वर्णित किया है, बाद में मॉडल को केवल सहेजे गए पथ प्रमुख से लोड किया जाना चाहिए, तो चलिए गैर-मुख्य श्रमिकों को अस्थायी हटा दें:

 if not _is_chief(task_type, task_id):
  tf.io.gfile.rmtree(os.path.dirname(write_model_path))
 

अब, जब लोड करने का समय आ गया है, तो सुविधाजनक tf.keras.models.load_model API का उपयोग करें, और आगे के काम के साथ जारी रखें। यहां, हम केवल एक कार्यकर्ता को लोड करने और प्रशिक्षण जारी रखने के लिए उपयोग करते हैं, जिस स्थिति में आप किसी अन्य strategy.scope() भीतर tf.keras.models.load_model को कॉल नहीं करते हैं। strategy.scope()

 loaded_model = tf.keras.models.load_model(model_path)

# Now that we have the model restored, and can continue with the training.
loaded_model.fit(single_worker_dataset, epochs=2, steps_per_epoch=20)
 
Epoch 1/2
20/20 [==============================] - 0s 2ms/step - loss: 1.9825 - accuracy: 0.1102
Epoch 2/2
20/20 [==============================] - 0s 2ms/step - loss: 1.9367 - accuracy: 0.1117

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

चेकपॉइंट सेविंग और रिस्टोर करना

दूसरी ओर, चेकपॉइंटिंग आपको मॉडल के वजन को बचाने और पूरे मॉडल को बचाने के बिना उन्हें पुनर्स्थापित करने की अनुमति देता है। यहाँ, आप एक tf.train.Checkpoint जो मॉडल को ट्रैक करता है, जिसे tf.train.CheckpointManager द्वारा प्रबंधित किया जाता है ताकि केवल नवीनतम चेकपॉइंट संरक्षित रहे।

 checkpoint_dir = '/tmp/ckpt'

checkpoint = tf.train.Checkpoint(model=multi_worker_model)
write_checkpoint_dir = write_filepath(checkpoint_dir, task_type, task_id)
checkpoint_manager = tf.train.CheckpointManager(
  checkpoint, directory=write_checkpoint_dir, max_to_keep=1)
 

एक बार जब CheckpointManager सेट हो जाता है, तो आप अब सहेजने के लिए तैयार हैं, और उन चौकियों को हटा दें जिन्हें गैर-मुख्य कार्यकर्ता ने सहेजा है।

 checkpoint_manager.save()
if not _is_chief(task_type, task_id):
  tf.io.gfile.rmtree(write_checkpoint_dir)
 

अब, जब आपको पुनर्स्थापित करने की आवश्यकता होती है, तो आप सुविधाजनक tf.train.latest_checkpoint फ़ंक्शन का उपयोग करके सहेजे गए नवीनतम चेकपॉइंट पा सकते हैं। चौकी को बहाल करने के बाद, आप प्रशिक्षण के साथ जारी रख सकते हैं।

 latest_checkpoint = tf.train.latest_checkpoint(checkpoint_dir)
checkpoint.restore(latest_checkpoint)
multi_worker_model.fit(multi_worker_dataset, epochs=2, steps_per_epoch=20)
 
Epoch 1/2
20/20 [==============================] - 0s 3ms/step - loss: 1.9841 - accuracy: 0.6561
Epoch 2/2
20/20 [==============================] - 0s 3ms/step - loss: 1.9445 - accuracy: 0.6805

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

BackupAndRestore कॉलबैक

BackupAndRestore कॉलबैक के तहत मॉडल और एक अस्थायी चौकी फ़ाइल में वर्तमान युग संख्या का बैकअप लेने से, दोष सहिष्णुता सुविधा प्रदान करता है backup_dir को तर्क BackupAndRestore । यह प्रत्येक युग के अंत में किया जाता है।

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

इसका उपयोग करने के लिए, tf.keras.callbacks.experimental.BackupAndRestore का एक उदाहरण tf.keras.Model.fit() कॉल करें।

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

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

वर्तमान में, BackupAndRestore कॉलबैक सिंगल कामगार को बिना किसी रणनीति के, मिररडस्ट्रोस्ट्रैटी और मल्टी-वर्कर के साथ MultiWorkerMirroredStrategy का समर्थन करता है। नीचे बहु-कार्यकर्ता प्रशिक्षण और एकल कार्यकर्ता प्रशिक्षण दोनों के लिए दो उदाहरण दिए गए हैं।

 # Multi-worker training with MultiWorkerMirroredStrategy.

callbacks = [tf.keras.callbacks.experimental.BackupAndRestore(backup_dir='/tmp/backup')]
with strategy.scope():
  multi_worker_model = build_and_compile_cnn_model()
multi_worker_model.fit(multi_worker_dataset,
                       epochs=3,
                       steps_per_epoch=70,
                       callbacks=callbacks)
 
Epoch 1/3
70/70 [==============================] - 0s 3ms/step - loss: 2.2837 - accuracy: 0.1836
Epoch 2/3
70/70 [==============================] - 0s 3ms/step - loss: 2.2131 - accuracy: 0.4091
Epoch 3/3
70/70 [==============================] - 0s 3ms/step - loss: 2.1310 - accuracy: 0.5485

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

यदि आप backup_dir आपके द्वारा बताए गए BackupAndRestore की निर्देशिका का निरीक्षण करते हैं, तो आप कुछ अस्थायी रूप से उत्पन्न चेकपॉइंट फ़ाइलों को देख सकते हैं। पहले खोए हुए उदाहरणों को पुनर्प्राप्त करने के लिए उन फ़ाइलों की आवश्यकता होती है, और उन्हें आपके प्रशिक्षण से बाहर निकलने पर tf.keras.Model.fit() के अंत में लाइब्रेरी द्वारा हटा दिया जाएगा।

यह सभी देखें

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