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

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

अवलोकन

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

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

उपयोग करने के लिए कैसे जानने के लिए MultiWorkerMirroredStrategy Keras और एक कस्टम प्रशिक्षण पाश के साथ, का उल्लेख Keras और MultiWorkerMirroredStrategy के साथ कस्टम प्रशिक्षण पाश

ध्यान दें कि इस ट्यूटोरियल का उद्देश्य दो श्रमिकों के साथ न्यूनतम बहु-कार्यकर्ता उदाहरण प्रदर्शित करना है।

सेट अप

कुछ आवश्यक आयातों के साथ प्रारंभ करें:

import json
import os
import sys

TensorFlow आयात करने से पहले, पर्यावरण में कुछ बदलाव करें:

  1. सभी GPU अक्षम करें। यह एक ही GPU का उपयोग करने की कोशिश कर रहे सभी श्रमिकों के कारण होने वाली त्रुटियों को रोकता है। वास्तविक दुनिया के अनुप्रयोग में, प्रत्येक कार्यकर्ता एक अलग मशीन पर होगा।
os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
  1. रीसेट TF_CONFIG वातावरण चर (आप बाद में इस बारे में और जानेंगे):
os.environ.pop('TF_CONFIG', None)
  1. सुनिश्चित करें कि वर्तमान निर्देशिका पायथन के चालू है लीक से इस द्वारा लिखित फ़ाइलें आयात करने की अनुमति देता है नोटबुक %%writefile बाद में:
if '.' not in sys.path:
  sys.path.insert(0, '.')

अब TensorFlow आयात करें:

import tensorflow as tf

डेटासेट और मॉडल परिभाषा

इसके बाद, एक बनाने mnist.py एक साधारण मॉडल और डेटासेट सेटअप के साथ फ़ाइल। इस ट्यूटोरियल में कार्यकर्ता-प्रक्रियाओं द्वारा इस पायथन फ़ाइल का उपयोग किया जाएगा:

%%writefile mnist.py

import os
import tensorflow as tf
import numpy as np

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 [0, 255] range.
  # You need to convert them to float32 with values in the [0, 1] range.
  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

def build_and_compile_cnn_model():
  model = tf.keras.Sequential([
      tf.keras.layers.InputLayer(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
Writing mnist.py

एकल कार्यकर्ता पर मॉडल प्रशिक्षण

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

import mnist

batch_size = 64
single_worker_dataset = mnist.mnist_dataset(batch_size)
single_worker_model = mnist.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
11501568/11490434 [==============================] - 0s 0us/step
2021-08-20 01:21:51.478839: E tensorflow/stream_executor/cuda/cuda_driver.cc:271] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected
2021-08-20 01:21:51.478914: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:169] retrieving CUDA diagnostic information for host: kokoro-gcp-ubuntu-prod-2087993482
2021-08-20 01:21:51.478928: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:176] hostname: kokoro-gcp-ubuntu-prod-2087993482
2021-08-20 01:21:51.479029: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:200] libcuda reported version is: 470.57.2
2021-08-20 01:21:51.479060: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:204] kernel reported version is: 470.57.2
2021-08-20 01:21:51.479067: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:310] kernel version seems to match DSO: 470.57.2
2021-08-20 01:21:51.480364: 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.
Epoch 1/3
 1/70 [..............................] - ETA: 26s - loss: 2.3067 - accuracy: 0.0469
2021-08-20 01:21:52.316481: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:185] None of the MLIR Optimization Passes are enabled (registered 2)
70/70 [==============================] - 1s 12ms/step - loss: 2.2829 - accuracy: 0.1667
Epoch 2/3
70/70 [==============================] - 1s 12ms/step - loss: 2.2281 - accuracy: 0.3842
Epoch 3/3
70/70 [==============================] - 1s 12ms/step - loss: 2.1625 - accuracy: 0.5348
<keras.callbacks.History at 0x7f633d957390>

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

आइए अब बहु-कार्यकर्ता प्रशिक्षण की दुनिया में प्रवेश करें।

नौकरियों और कार्यों के साथ एक समूह

TensorFlow में, वितरित प्रशिक्षण शामिल है: एक 'cluster' कई नौकरियों के साथ, और नौकरियों में से हर एक या एक से अधिक हो सकता है 'task' है।

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

वहाँ एक के दो घटक हैं TF_CONFIG : चर 'cluster' और 'task'

  • एक 'cluster' सभी कर्मचारियों के लिए ही है और प्रशिक्षण क्लस्टर है, जो इस तरह के रूप नौकरियों के विभिन्न प्रकार, से मिलकर dict है के बारे में जानकारी प्रदान करता है 'worker' या 'chief'

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

नीचे एक उदाहरण विन्यास है:

tf_config = {
    'cluster': {
        'worker': ['localhost:12345', 'localhost:23456']
    },
    'task': {'type': 'worker', 'index': 0}
}

यहाँ एक ही है TF_CONFIG JSON स्ट्रिंग के रूप धारावाहिक:

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

ध्यान दें कि tf_config सिर्फ पायथन में एक स्थानीय चर रहा है। एक प्रशिक्षण विन्यास के लिए उपयोग करने में सक्षम होने के लिए इस dict एक JSON के रूप में श्रृंखलाबद्ध और एक में रखा जाना चाहिए TF_CONFIG वातावरण चर।

ऊपर के उदाहरण विन्यास में, आप कार्य सेट 'type' के लिए 'worker' और कार्य 'index' करने के लिए 0 । इसलिए, इस मशीन पहले कार्यकर्ता है। यह रूप में नियुक्त किया जाएगा 'chief' कार्यकर्ता और दूसरों की तुलना में अधिक काम करना।

समझाने के उद्देश्य से, इस ट्यूटोरियल दिखाता है कि कैसे आप एक निर्धारित कर सकते हैं TF_CONFIG दो कार्यकर्ताओं के साथ चर एक पर localhost

अभ्यास में, आप बाहरी IP पते / बंदरगाहों पर एक से अधिक कार्यकर्ताओं बना सकते हैं और एक स्थापित करेगा TF_CONFIG तदनुसार प्रत्येक कार्यकर्ता पर चर।

इस ट्यूटोरियल में, आप दो श्रमिकों का उपयोग करेंगे:

  • पहले ( 'chief' ) कार्यकर्ता TF_CONFIG ऊपर दिखाया गया है।
  • दूसरे कार्यकर्ता के लिए, आप सेट हो जाएगा tf_config['task']['index']=1

नोटबुक में पर्यावरण चर और उपप्रक्रियाएं

उपप्रक्रियाएं अपने माता-पिता से पर्यावरण चर प्राप्त करती हैं।

उदाहरण के लिए, आप इस जुपिटर नोटबुक प्रक्रिया में निम्नानुसार एक पर्यावरण चर सेट कर सकते हैं:

os.environ['GREETINGS'] = 'Hello TensorFlow!'

फिर, आप उप-प्रक्रियाओं से पर्यावरण चर का उपयोग कर सकते हैं:

echo ${GREETINGS}
Hello TensorFlow!

अगले भाग में, आप पारित करने के लिए इसी तरह की एक विधि का उपयोग करेंगे TF_CONFIG कार्यकर्ता subprocesses करने के लिए। वास्तविक दुनिया के परिदृश्य में, आप अपनी नौकरियों को इस तरह से लॉन्च नहीं करेंगे, लेकिन यह इस उदाहरण में पर्याप्त है।

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

TensorFlow में, वितरित प्रशिक्षण के दो मुख्य रूप हैं:

  • तुल्यकालिक प्रशिक्षण, जहां प्रशिक्षण के कदम कार्यकर्ताओं और प्रतिकृतियां भर में सिंक किए गए हैं, और
  • अतुल्यकालिक प्रशिक्षण, जहां प्रशिक्षण चरणों सख्ती से समन्वयन नहीं किया जाता (उदाहरण के लिए, पैरामीटर सर्वर प्रशिक्षण )।

इस ट्यूटोरियल दर्शाता है कि कैसे तुल्यकालिक बहु कार्यकर्ता प्रशिक्षण प्रदर्शन करने का एक उदाहरण का उपयोग करते हुए tf.distribute.MultiWorkerMirroredStrategy

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

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:CPU:0',), communication = CommunicationImplementation.AUTO

MultiWorkerMirroredStrategy के माध्यम से कई कार्यान्वयन प्रदान करता है CommunicationOptions पैरामीटर: 1) RING औजार अंगूठी आधारित gRPC पार मेजबान संचार परत के रूप में उपयोग करते हुए समूहवाचक; 2) NCCL का उपयोग करता है NVIDIA सामूहिक संचार पुस्तकालय समूहवाचक लागू करने के लिए; और 3) AUTO क्रम को पसंद defers। सामूहिक कार्यान्वयन का सबसे अच्छा विकल्प GPU की संख्या और प्रकार और क्लस्टर में नेटवर्क इंटरकनेक्ट पर निर्भर करता है।

मॉडल को प्रशिक्षित करें

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

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

वास्तव में साथ चलने के लिए MultiWorkerMirroredStrategy आप कार्यकर्ता प्रक्रियाओं चलाने के लिए और एक में उत्तीर्ण होना होगा TF_CONFIG उन्हें।

जैसा mnist.py पहले लिखा फ़ाइल, यहाँ है main.py कि श्रमिकों के प्रत्येक चलेंगे:

%%writefile main.py

import os
import json

import tensorflow as tf
import mnist

per_worker_batch_size = 64
tf_config = json.loads(os.environ['TF_CONFIG'])
num_workers = len(tf_config['cluster']['worker'])

strategy = tf.distribute.MultiWorkerMirroredStrategy()

global_batch_size = per_worker_batch_size * num_workers
multi_worker_dataset = mnist.mnist_dataset(global_batch_size)

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


multi_worker_model.fit(multi_worker_dataset, epochs=3, steps_per_epoch=70)
Writing main.py

ध्यान दें कि ऊपर कोड स्निपेट में global_batch_size है, जो करने के लिए पारित हो Dataset.batch , पर सेट है per_worker_batch_size * num_workers । यह सुनिश्चित करता है प्रत्येक कार्यकर्ता के बैच प्रक्रियाओं कि per_worker_batch_size श्रमिकों की संख्या की परवाह किए बिना उदाहरण।

वर्तमान निर्देशिका में अब दोनों पायथन फाइलें हैं:

ls *.py
main.py
mnist.py

तो json-क्रमानुसार TF_CONFIG और वातावरण चरों में जोड़ें:

os.environ['TF_CONFIG'] = json.dumps(tf_config)

अब, आप एक कार्यकर्ता प्रक्रिया को चलाई जाने शुरू कर सकते हैं main.py और प्रयोग TF_CONFIG :

# first kill any previous runs
%killbgscripts
All background processes were killed.
python main.py &> job_0.log

उपरोक्त आदेश के बारे में ध्यान देने योग्य कुछ बातें हैं:

  1. यह का उपयोग करता है %%bash जो एक है नोटबुक "जादू" कुछ बैश आदेशों को चलाने के लिए।
  2. यह का उपयोग करता है --bg चलाने के लिए झंडा bash पृष्ठभूमि में प्रक्रिया, क्योंकि इस कार्यकर्ता को समाप्त नहीं होंगे। यह शुरू होने से पहले सभी श्रमिकों की प्रतीक्षा करता है।

Backgrounded वर्कर प्रोसेस, इस नोटबुक के लिए उत्पादन मुद्रित नहीं होगा तो &> एक फाइल करने के लिए इसके उत्पादन पुनर्निर्देश ताकि आप निरीक्षण कर सकते हैं, जो बाद में एक लॉग फ़ाइल में हुआ था।

इसलिए, प्रक्रिया शुरू होने के लिए कुछ सेकंड प्रतीक्षा करें:

import time
time.sleep(10)

अब, निरीक्षण करें कि कार्यकर्ता की लॉग फ़ाइल में अब तक क्या आउटपुट रहा है:

cat job_0.log
2021-08-20 01:21:57.459034: E tensorflow/stream_executor/cuda/cuda_driver.cc:271] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected
2021-08-20 01:21:57.459133: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:169] retrieving CUDA diagnostic information for host: kokoro-gcp-ubuntu-prod-2087993482
2021-08-20 01:21:57.459414: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:176] hostname: kokoro-gcp-ubuntu-prod-2087993482
2021-08-20 01:21:57.459531: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:200] libcuda reported version is: 470.57.2
2021-08-20 01:21:57.459575: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:204] kernel reported version is: 470.57.2
2021-08-20 01:21:57.459586: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:310] kernel version seems to match DSO: 470.57.2
2021-08-20 01:21:57.460413: 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-08-20 01:21:57.466180: I tensorflow/core/distributed_runtime/rpc/grpc_channel.cc:272] Initialize GrpcChannelCache for job worker -> {0 -> localhost:12345, 1 -> localhost:23456}
2021-08-20 01:21:57.466667: I tensorflow/core/distributed_runtime/rpc/grpc_server_lib.cc:427] Started server with target: grpc://localhost:12345

लॉग फ़ाइल की अंतिम पंक्ति कहना चाहिए: Started server with target: grpc://localhost:12345 । पहला कार्यकर्ता अब तैयार है, और अन्य सभी कार्यकर्ताओं के आगे बढ़ने के लिए तैयार होने की प्रतीक्षा कर रहा है।

तो अद्यतन tf_config दूसरे कार्यकर्ता प्रक्रिया लेने के लिए के लिए:

tf_config['task']['index'] = 1
os.environ['TF_CONFIG'] = json.dumps(tf_config)

दूसरा कार्यकर्ता लॉन्च करें। यह प्रशिक्षण शुरू करेगा क्योंकि सभी कार्यकर्ता सक्रिय हैं (इसलिए इस प्रक्रिया को पृष्ठभूमि में रखने की कोई आवश्यकता नहीं है):

python main.py
Epoch 1/3
70/70 [==============================] - 6s 54ms/step - loss: 2.2796 - accuracy: 0.1292
Epoch 2/3
70/70 [==============================] - 4s 51ms/step - loss: 2.2285 - accuracy: 0.2898
Epoch 3/3
70/70 [==============================] - 4s 54ms/step - loss: 2.1706 - accuracy: 0.4835
2021-08-20 01:22:07.529925: E tensorflow/stream_executor/cuda/cuda_driver.cc:271] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected
2021-08-20 01:22:07.529987: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:169] retrieving CUDA diagnostic information for host: kokoro-gcp-ubuntu-prod-2087993482
2021-08-20 01:22:07.529996: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:176] hostname: kokoro-gcp-ubuntu-prod-2087993482
2021-08-20 01:22:07.530089: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:200] libcuda reported version is: 470.57.2
2021-08-20 01:22:07.530125: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:204] kernel reported version is: 470.57.2
2021-08-20 01:22:07.530136: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:310] kernel version seems to match DSO: 470.57.2
2021-08-20 01:22:07.530785: 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-08-20 01:22:07.536395: I tensorflow/core/distributed_runtime/rpc/grpc_channel.cc:272] Initialize GrpcChannelCache for job worker -> {0 -> localhost:12345, 1 -> localhost:23456}
2021-08-20 01:22:07.536968: I tensorflow/core/distributed_runtime/rpc/grpc_server_lib.cc:427] Started server with target: grpc://localhost:23456
2021-08-20 01:22:08.764867: 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: "TensorSliceDataset/_2"
op: "TensorSliceDataset"
input: "Placeholder/_0"
input: "Placeholder/_1"
attr {
  key: "Toutput_types"
  value {
    list {
      type: DT_FLOAT
      type: DT_INT64
    }
  }
}
attr {
  key: "output_shapes"
  value {
    list {
      shape {
        dim {
          size: 28
        }
        dim {
          size: 28
        }
      }
      shape {
      }
    }
  }
}

2021-08-20 01:22:08.983898: W tensorflow/core/framework/dataset.cc:679] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.
2021-08-20 01:22:08.985655: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:185] None of the MLIR Optimization Passes are enabled (registered 2)

यदि आप पहले कार्यकर्ता द्वारा लिखे गए लॉग को दोबारा जांचते हैं, तो आप सीखेंगे कि उसने उस मॉडल के प्रशिक्षण में भाग लिया था:

cat job_0.log
2021-08-20 01:21:57.459034: E tensorflow/stream_executor/cuda/cuda_driver.cc:271] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected
2021-08-20 01:21:57.459133: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:169] retrieving CUDA diagnostic information for host: kokoro-gcp-ubuntu-prod-2087993482
2021-08-20 01:21:57.459414: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:176] hostname: kokoro-gcp-ubuntu-prod-2087993482
2021-08-20 01:21:57.459531: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:200] libcuda reported version is: 470.57.2
2021-08-20 01:21:57.459575: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:204] kernel reported version is: 470.57.2
2021-08-20 01:21:57.459586: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:310] kernel version seems to match DSO: 470.57.2
2021-08-20 01:21:57.460413: 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-08-20 01:21:57.466180: I tensorflow/core/distributed_runtime/rpc/grpc_channel.cc:272] Initialize GrpcChannelCache for job worker -> {0 -> localhost:12345, 1 -> localhost:23456}
2021-08-20 01:21:57.466667: I tensorflow/core/distributed_runtime/rpc/grpc_server_lib.cc:427] Started server with target: grpc://localhost:12345
2021-08-20 01:22:08.759563: 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: "TensorSliceDataset/_2"
op: "TensorSliceDataset"
input: "Placeholder/_0"
input: "Placeholder/_1"
attr {
  key: "Toutput_types"
  value {
    list {
      type: DT_FLOAT
      type: DT_INT64
    }
  }
}
attr {
  key: "output_shapes"
  value {
    list {
      shape {
        dim {
          size: 28
        }
        dim {
          size: 28
        }
      }
      shape {
      }
    }
  }
}

2021-08-20 01:22:08.976883: W tensorflow/core/framework/dataset.cc:679] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.
2021-08-20 01:22:08.978435: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:185] None of the MLIR Optimization Passes are enabled (registered 2)
Epoch 1/3
70/70 [==============================] - 6s 54ms/step - loss: 2.2796 - accuracy: 0.1292
Epoch 2/3
70/70 [==============================] - 4s 52ms/step - loss: 2.2285 - accuracy: 0.2898
Epoch 3/3
70/70 [==============================] - 4s 54ms/step - loss: 2.1706 - accuracy: 0.4835

आश्चर्य, इस भाग गया परीक्षण की तुलना में धीमी इस ट्यूटोरियल की शुरुआत में चलाते हैं।

एक ही मशीन पर कई कर्मचारियों को चलाने से केवल ओवरहेड जुड़ता है।

यहां लक्ष्य प्रशिक्षण के समय में सुधार करना नहीं था, बल्कि केवल बहु-कार्यकर्ता प्रशिक्षण का उदाहरण देना था।

# Delete the `TF_CONFIG`, and kill any background tasks so they don't affect the next section.
os.environ.pop('TF_CONFIG', None)
%killbgscripts
All background processes were killed.

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

अब तक, आपने सीखा है कि बुनियादी बहु-कार्यकर्ता सेटअप कैसे किया जाता है।

शेष ट्यूटोरियल के दौरान, आप अन्य कारकों के बारे में जानेंगे, जो वास्तविक उपयोग के मामलों के लिए उपयोगी या महत्वपूर्ण हो सकते हैं, विस्तार से।

डेटासेट शार्डिंग

बहु कार्यकर्ता प्रशिक्षण में, डाटासेट sharding अभिसरण और प्रदर्शन को सुनिश्चित करने की जरूरत है।

पिछले अनुभाग में उदाहरण के द्वारा प्रदान की डिफ़ॉल्ट autosharding पर निर्भर करता है tf.distribute.Strategy एपीआई। आप की स्थापना करके sharding नियंत्रित कर सकते हैं tf.data.experimental.AutoShardPolicy की tf.data.experimental.DistributeOptions

ऑटो sharding के बारे में अधिक जानने के लिए, का उल्लेख वितरित इनपुट गाइड

यहाँ कैसे ऑटो बंद sharding, इसलिए प्रत्येक प्रतिकृति हर उदाहरण (अनुशंसित नहीं) संसाधित करता है कि चालू करने के लिए की एक त्वरित उदाहरण है:

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

global_batch_size = 64
multi_worker_dataset = mnist.mnist_dataset(batch_size=64)
dataset_no_auto_shard = multi_worker_dataset.with_options(options)

मूल्यांकन

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

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

मूल्यांकन के लिए दोहराए गए डेटासेट की भी सिफारिश की जाती है।

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

प्रदर्शन

अब आप एक Keras मॉडल है कि सभी के साथ कई कार्यकर्ताओं में चलाने के लिए सेट अप है MultiWorkerMirroredStrategy

बहु-कार्यकर्ता प्रशिक्षण के प्रदर्शन में सुधार करने के लिए, आप निम्न प्रयास कर सकते हैं:

  • tf.distribute.MultiWorkerMirroredStrategy कई प्रदान करता है सामूहिक संचार कार्यान्वयन :

    • RING औजार अंगूठी आधारित gRPC पार मेजबान संचार परत के रूप में उपयोग करते हुए समूहवाचक।
    • NCCL का उपयोग करता है NVIDIA सामूहिक संचार पुस्तकालय समूहवाचक लागू करने के लिए।
    • AUTO क्रम को पसंद defers।

    सामूहिक कार्यान्वयन का सबसे अच्छा विकल्प GPU की संख्या, GPU के प्रकार और क्लस्टर में नेटवर्क इंटरकनेक्ट पर निर्भर करता है। स्वत: विकल्प ओवरराइड करने के लिए, निर्दिष्ट communication_options के पैरामीटर MultiWorkerMirroredStrategy के निर्माता। उदाहरण के लिए:

    communication_options=tf.distribute.experimental.CommunicationOptions(implementation=tf.distribute.experimental.CollectiveCommunication.NCCL)
    
  • करने के लिए चर कास्ट tf.float यदि संभव हो तो:

    • आधिकारिक ResNet मॉडल भी शामिल है एक उदाहरण यह कैसे किया जा सकता है की।

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

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

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

जब कोई कार्यकर्ता अनुपलब्ध हो जाता है, तो अन्य कर्मचारी विफल हो जाएंगे (संभवतः एक समय समाप्त होने के बाद)। ऐसे मामलों में, अनुपलब्ध कार्यकर्ता को पुनः आरंभ करने की आवश्यकता होती है, साथ ही अन्य कर्मचारी जो विफल हो गए हैं।

मॉडलचेकपॉइंट कॉलबैक

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

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

वैकल्पिक रूप से उपयोगकर्ता के बाहर बचाने के लिए और मॉडल / वजन बहाल करने के लिए चुन सकते हैं ModelCheckpoint कॉलबैक।

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

अपने मॉडल का उपयोग कर बचाने के लिए model.save या tf.saved_model.save , बचत गंतव्य की जरूरत प्रत्येक कार्यकर्ता के लिए अलग अलग हो सकता है।

  • गैर-मुख्य कर्मचारियों के लिए, आपको मॉडल को अस्थायी निर्देशिका में सहेजना होगा।
  • प्रमुख के लिए, आपको प्रदान की गई मॉडल निर्देशिका में सहेजना होगा।

एक ही स्थान पर लिखने की कोशिश कर रहे कई श्रमिकों के परिणामस्वरूप त्रुटियों को रोकने के लिए कार्यकर्ता पर अस्थायी निर्देशिकाओं को अद्वितीय होना चाहिए।

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

आपके पास कुछ सफाई तर्क होना चाहिए जो आपके प्रशिक्षण के पूरा होने के बाद श्रमिकों द्वारा बनाई गई अस्थायी निर्देशिकाओं को हटा देता है।

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

का उपयोग करते हुए MultiWorkerMirroredStrategy , कार्यक्रम के क्रम जानना आवश्यक है कि वर्तमान कार्यकर्ता प्रमुख है में हर कार्यकर्ता पर चलाया जाता है, और, यह क्लस्टर समाधानकर्ता उद्देश्य यह है कि जिम्मेदार बताते है का लाभ लेता है task_type और task_id :

  • task_type बताता है कि मौजूदा नौकरी (जैसे है 'worker' )।
  • task_id आप कार्यकर्ता की पहचानकर्ता बताता है।
  • साथ कार्यकर्ता task_id == 0 मुख्य कार्यकर्ता के रूप में नामित किया गया है।

कोड में नीचे स्निपेट write_filepath समारोह लिखने के लिए फ़ाइल पथ, जो कार्यकर्ता पर निर्भर करता है प्रदान करता है task_id :

  • मुख्य कार्यकर्ता (साथ के लिए task_id == 0 ), यह मूल फ़ाइल पथ के लिए लिखता है।
  • अन्य कर्मचारियों के लिए, यह एक अस्थायी निर्देशिका- बनाता temp_dir -साथ task_id में लिखने के लिए निर्देशिका पथ में:
model_path = '/tmp/keras-model'

def _is_chief(task_type, task_id):
  # Note: there are two possible `TF_CONFIG` configuration.
  #   1) In addition to `worker` tasks, a `chief` task type is use;
  #      in this case, this function should be modified to
  #      `return task_type == 'chief'`.
  #   2) Only `worker` task type is used; in this case, worker 0 is
  #      regarded as the chief. The implementation demonstrated here
  #      is for this case.
  # For the purpose of this Colab section, the `task_type is None` case
  # is added because it is effectively run with only a single worker.
  return (task_type == 'worker' and task_id == 0) or task_type is None

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)
2021-08-20 01:22:24.305980: W tensorflow/python/util/util.cc:348] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
INFO:tensorflow:Assets written to: /tmp/keras-model/assets
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 एपीआई, और आगे काम के साथ जारी है।

इधर, केवल लोड करने के लिए एक कार्यकर्ता का उपयोग कर और प्रशिक्षण, जिस स्थिति में आप नहीं कॉल करना जारी रखने के लिए यह मानें कि tf.keras.models.load_model एक और भीतर strategy.scope() (ध्यान दें कि strategy = tf.distribute.MultiWorkerMirroredStrategy() , परिभाषित के रूप में पहले ):

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

# Now that the model is restored, and can continue with the training.
loaded_model.fit(single_worker_dataset, epochs=2, steps_per_epoch=20)
Epoch 1/2
20/20 [==============================] - 1s 16ms/step - loss: 2.2960 - accuracy: 0.0000e+00
Epoch 2/2
20/20 [==============================] - 0s 15ms/step - loss: 2.2795 - accuracy: 0.0000e+00
<keras.callbacks.History at 0x7f633b103910>

चेकपॉइंट को सहेजना और बहाल करना

दूसरी ओर, चेकपॉइंटिंग से आप अपने मॉडल के वज़न को बचा सकते हैं और पूरे मॉडल को सहेजे बिना उन्हें पुनर्स्थापित कर सकते हैं।

यहाँ, आप एक बनाएंगे 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)
2021-08-20 01:22:26.176660: 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: "TensorSliceDataset/_2"
op: "TensorSliceDataset"
input: "Placeholder/_0"
input: "Placeholder/_1"
attr {
  key: "Toutput_types"
  value {
    list {
      type: DT_FLOAT
      type: DT_INT64
    }
  }
}
attr {
  key: "output_shapes"
  value {
    list {
      shape {
        dim {
          size: 28
        }
        dim {
          size: 28
        }
      }
      shape {
      }
    }
  }
}

2021-08-20 01:22:26.388321: W tensorflow/core/framework/dataset.cc:679] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.
Epoch 1/2
20/20 [==============================] - 3s 13ms/step - loss: 2.2948 - accuracy: 0.0000e+00
Epoch 2/2
20/20 [==============================] - 0s 13ms/step - loss: 2.2785 - accuracy: 0.0000e+00
<keras.callbacks.History at 0x7f635d404450>

बैकअप और पुनर्स्थापना कॉलबैक

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

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

इसका इस्तेमाल करने के लिए, का एक उदाहरण प्रदान tf.keras.callbacks.experimental.BackupAndRestore पर Model.fit कॉल।

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

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

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

# Multi-worker training with MultiWorkerMirroredStrategy
# and the BackupAndRestore callback.

callbacks = [tf.keras.callbacks.experimental.BackupAndRestore(backup_dir='/tmp/backup')]
with strategy.scope():
  multi_worker_model = mnist.build_and_compile_cnn_model()
multi_worker_model.fit(multi_worker_dataset,
                       epochs=3,
                       steps_per_epoch=70,
                       callbacks=callbacks)
2021-08-20 01:22:29.530251: 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: "TensorSliceDataset/_2"
op: "TensorSliceDataset"
input: "Placeholder/_0"
input: "Placeholder/_1"
attr {
  key: "Toutput_types"
  value {
    list {
      type: DT_FLOAT
      type: DT_INT64
    }
  }
}
attr {
  key: "output_shapes"
  value {
    list {
      shape {
        dim {
          size: 28
        }
        dim {
          size: 28
        }
      }
      shape {
      }
    }
  }
}
Epoch 1/3
70/70 [==============================] - 3s 12ms/step - loss: 2.2759 - accuracy: 0.1625
Epoch 2/3
70/70 [==============================] - 1s 12ms/step - loss: 2.2146 - accuracy: 0.2761
Epoch 3/3
70/70 [==============================] - 1s 12ms/step - loss: 2.1456 - accuracy: 0.4344
<keras.callbacks.History at 0x7f635d2aac90>

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

अतिरिक्त संसाधन

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