एक सवाल है? TensorFlow फ़ोरम विज़िट फ़ोरम पर समुदाय से जुड़ें

Keras और MultiWorkerMirroredStrategy के साथ कस्टम ट्रेनिंग लूप

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

अवलोकन

यह ट्यूटोरियल कस्टम ट्रेनिंग लूप एपीआई के साथ मल्टी-वर्कर ट्रेनिंग को प्रदर्शित करता है, जिसे मल्टीवर्कर मिररडस्ट्रेटी के माध्यम से वितरित किया जाता है, इसलिए सिंगल-वर्कर पर चलने के लिए डिज़ाइन किया गया केरस मॉडल न्यूनतम कोड परिवर्तन के साथ कई वर्कर्स पर मूल रूप से काम कर सकता है।

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

यदि आप MultiWorkerMirroredStrategy साथ MultiWorkerMirroredStrategy का उपयोग करना model.fit , तो इसके बजाय इस ट्यूटोरियल को देखें।

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

सेट अप

सबसे पहले, कुछ आवश्यक आयात।

०४२२एफबी७५५०

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

सभी GPU अक्षम करें। यह एक ही GPU का उपयोग करने की कोशिश कर रहे सभी श्रमिकों के कारण होने वाली त्रुटियों को रोकता है। एक वास्तविक अनुप्रयोग के लिए प्रत्येक कार्यकर्ता एक अलग मशीन पर होगा।

os.environ["CUDA_VISIBLE_DEVICES"] = "-1"

TF_CONFIG परिवेश चर रीसेट करें, आप इसके बारे में बाद में और देखेंगे।

os.environ.pop('TF_CONFIG', None)

सुनिश्चित करें कि वर्तमान निर्देशिका अजगर के पथ पर है। यह नोटबुक को %%writefile द्वारा लिखी गई फाइलों को बाद में आयात करने की अनुमति देता है।

if '.' not in sys.path:
  sys.path.insert(0, '.')

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

import tensorflow as tf

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

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

०३७बीबीए८सी८० ०८बी६डी९६७३०

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

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

अपने क्लस्टर का वर्णन करें

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

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 दो घटक हैं: cluster और task

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

  • task वर्तमान कार्य की जानकारी प्रदान करता है और प्रत्येक कार्यकर्ता पर अलग होता है। यह उस कार्यकर्ता के type और index को निर्दिष्ट करता है।

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

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

इस उदाहरण में आप 2 श्रमिकों का उपयोग करेंगे, पहले कार्यकर्ता का TF_CONFIG ऊपर दिखाया गया है। दूसरे कार्यकर्ता के लिए आप सेट करेंगे tf_config['task']['index']=1

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

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

उपप्रक्रियाओं को अपने माता-पिता से पर्यावरण चर विरासत में मिलते हैं। इसलिए यदि आप इस jupyter notebook प्रक्रिया में एक पर्यावरण चर सेट करते हैं:

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

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

echo ${GREETINGS}
Hello TensorFlow!

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

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

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

strategy = tf.distribute.MultiWorkerMirroredStrategy()
INFO:tensorflow:Single-worker MultiWorkerMirroredStrategy with local_devices = ('/device:CPU:0',), communication = CommunicationImplementation.AUTO

यह निर्दिष्ट करने के लिए कि आपके मॉडल का निर्माण करते समय एक रणनीति का उपयोग किया जाना चाहिए, tf.distribute.Strategy.scope का उपयोग करें। यह आपको इस रणनीति के लिए " क्रॉस-रेप्लिका संदर्भ " में डालता है, जिसका अर्थ है कि रणनीति को चर प्लेसमेंट जैसी चीजों के नियंत्रण में रखा गया है।

import mnist
with strategy.scope():
  # Model building needs to be within `strategy.scope()`.
  multi_worker_model = mnist.build_cnn_model()
WARNING:tensorflow:Please add `keras.layers.InputLayer` instead of `keras.Input` to Sequential model. `keras.Input` is intended to be used by Functional model.

कर्मचारियों के बीच अपने डेटा को ऑटो-शेयर करें

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

देखें: distribute_datasets_from_function

per_worker_batch_size = 64
num_workers = len(tf_config['cluster']['worker'])
global_batch_size = per_worker_batch_size * num_workers

with strategy.scope():
  multi_worker_dataset = strategy.distribute_datasets_from_function(
      lambda input_context: mnist.dataset_fn(global_batch_size, input_context))

कस्टम प्रशिक्षण लूप को परिभाषित करें और मॉडल को प्रशिक्षित करें

एक अनुकूलक निर्दिष्ट करें

with strategy.scope():
  # The creation of optimizer and train_accuracy will need to be in
  # `strategy.scope()` as well, since they create variables.
  optimizer = tf.keras.optimizers.RMSprop(learning_rate=0.001)
  train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(
      name='train_accuracy')

tf.function साथ एक प्रशिक्षण चरण को परिभाषित करें

@tf.function
def train_step(iterator):
  """Training step function."""

  def step_fn(inputs):
    """Per-Replica step function."""
    x, y = inputs
    with tf.GradientTape() as tape:
      predictions = multi_worker_model(x, training=True)
      per_batch_loss = tf.keras.losses.SparseCategoricalCrossentropy(
          from_logits=True,
          reduction=tf.keras.losses.Reduction.NONE)(y, predictions)
      loss = tf.nn.compute_average_loss(
          per_batch_loss, global_batch_size=global_batch_size)

    grads = tape.gradient(loss, multi_worker_model.trainable_variables)
    optimizer.apply_gradients(
        zip(grads, multi_worker_model.trainable_variables))
    train_accuracy.update_state(y, predictions)
    return loss

  per_replica_losses = strategy.run(step_fn, args=(next(iterator),))
  return strategy.reduce(
      tf.distribute.ReduceOp.SUM, per_replica_losses, axis=None)

चेकपॉइंट को सहेजना और पुनर्स्थापित करना

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

from multiprocessing import util
checkpoint_dir = os.path.join(util.get_temp_dir(), 'ckpt')

def _is_chief(task_type, task_id):
  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)

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

epoch = tf.Variable(
    initial_value=tf.constant(0, dtype=tf.dtypes.int64), name='epoch')
step_in_epoch = tf.Variable(
    initial_value=tf.constant(0, dtype=tf.dtypes.int64),
    name='step_in_epoch')
task_type, task_id = (strategy.cluster_resolver.task_type,
                      strategy.cluster_resolver.task_id)

checkpoint = tf.train.Checkpoint(
    model=multi_worker_model, epoch=epoch, step_in_epoch=step_in_epoch)

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)

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

latest_checkpoint = tf.train.latest_checkpoint(checkpoint_dir)
if latest_checkpoint:
  checkpoint.restore(latest_checkpoint)

चेकपॉइंट को पुनर्स्थापित करने के बाद, आप अपने कस्टम प्रशिक्षण लूप का प्रशिक्षण जारी रख सकते हैं।

num_epochs = 3
num_steps_per_epoch = 70

while epoch.numpy() < num_epochs:
  iterator = iter(multi_worker_dataset)
  total_loss = 0.0
  num_batches = 0

  while step_in_epoch.numpy() < num_steps_per_epoch:
    total_loss += train_step(iterator)
    num_batches += 1
    step_in_epoch.assign_add(1)

  train_loss = total_loss / num_batches
  print('Epoch: %d, accuracy: %f, train_loss: %f.'
                %(epoch.numpy(), train_accuracy.result(), train_loss))

  train_accuracy.reset_states()

  # Once the `CheckpointManager` is set up, you're now ready to save, and remove
  # the checkpoints non-chief workers saved.
  checkpoint_manager.save()
  if not _is_chief(task_type, task_id):
    tf.io.gfile.rmtree(write_checkpoint_dir)

  epoch.assign_add(1)
  step_in_epoch.assign(0)
Epoch: 0, accuracy: 0.835826, train_loss: 0.532438.
Epoch: 1, accuracy: 0.940402, train_loss: 0.201307.
Epoch: 2, accuracy: 0.959821, train_loss: 0.136761.

श्रमिकों पर पूर्ण कोड सेटअप

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

पहले लिखी गई mnist.py फ़ाइल की तरह, यहाँ main.py है जिसमें वही कोड है जो हमने पहले इस कोलाब में चरण दर चरण चला था, हम इसे केवल एक फ़ाइल में लिख रहे हैं ताकि प्रत्येक कर्मचारी इसे चलाए:

फ़ाइल: main.py

Writing main.py

ट्रेन और मूल्यांकन

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

ls *.py
main.py
mnist.py

तो TF_CONFIG json-serialize करें और इसे पर्यावरण चर में जोड़ें:

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

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

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

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

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

बैकग्राउंड वर्कर प्रक्रिया इस नोटबुक में आउटपुट प्रिंट नहीं करेगी, इसलिए &> इसके आउटपुट को एक फाइल पर रीडायरेक्ट करता है, ताकि आप देख सकें कि क्या हुआ।

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

import time
time.sleep(20)

अब देखें कि कार्यकर्ता के लॉगफाइल में अब तक क्या आउटपुट रहा है:

cat job_0.log
2021-05-19 11:28:34.994731: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudart.so.11.0
2021-05-19 11:28:36.180646: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcuda.so.1
2021-05-19 11:28:36.188591: E tensorflow/stream_executor/cuda/cuda_driver.cc:328] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected
2021-05-19 11:28:36.188631: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:169] retrieving CUDA diagnostic information for host: kokoro-gcp-ubuntu-prod-1521845
2021-05-19 11:28:36.188639: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:176] hostname: kokoro-gcp-ubuntu-prod-1521845
2021-05-19 11:28:36.188728: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:200] libcuda reported version is: 465.19.1
2021-05-19 11:28:36.188755: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:204] kernel reported version is: 465.19.1
2021-05-19 11:28:36.188762: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:310] kernel version seems to match DSO: 465.19.1
2021-05-19 11:28:36.189315: 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-05-19 11:28:36.194547: I tensorflow/core/distributed_runtime/rpc/grpc_channel.cc:301] Initialize GrpcChannelCache for job worker -> {0 -> localhost:12345, 1 -> localhost:23456}
2021-05-19 11:28:36.195001: I tensorflow/core/distributed_runtime/rpc/grpc_server_lib.cc:411] Started server with target: grpc://localhost:12345

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

इसलिए tf_config को अपडेट करें tf_config दूसरे कार्यकर्ता को पिक-अप करने की प्रक्रिया मिल सके:

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

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

python main.py > /dev/null 2>&1

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

cat job_0.log
2021-05-19 11:28:34.994731: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudart.so.11.0
2021-05-19 11:28:36.180646: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcuda.so.1
2021-05-19 11:28:36.188591: E tensorflow/stream_executor/cuda/cuda_driver.cc:328] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected
2021-05-19 11:28:36.188631: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:169] retrieving CUDA diagnostic information for host: kokoro-gcp-ubuntu-prod-1521845
2021-05-19 11:28:36.188639: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:176] hostname: kokoro-gcp-ubuntu-prod-1521845
2021-05-19 11:28:36.188728: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:200] libcuda reported version is: 465.19.1
2021-05-19 11:28:36.188755: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:204] kernel reported version is: 465.19.1
2021-05-19 11:28:36.188762: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:310] kernel version seems to match DSO: 465.19.1
2021-05-19 11:28:36.189315: 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-05-19 11:28:36.194547: I tensorflow/core/distributed_runtime/rpc/grpc_channel.cc:301] Initialize GrpcChannelCache for job worker -> {0 -> localhost:12345, 1 -> localhost:23456}
2021-05-19 11:28:36.195001: I tensorflow/core/distributed_runtime/rpc/grpc_server_lib.cc:411] Started server with target: grpc://localhost:12345
WARNING:tensorflow:Please add `keras.layers.InputLayer` instead of `keras.Input` to Sequential model. `keras.Input` is intended to be used by Functional model.
2021-05-19 11:28:57.264178: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:176] None of the MLIR Optimization Passes are enabled (registered 2)
2021-05-19 11:28:57.264494: I tensorflow/core/platform/profile_utils/cpu_utils.cc:114] CPU Frequency: 2000189999 Hz
Epoch: 0, accuracy: 0.821763, train_loss: 0.589336.
Epoch: 1, accuracy: 0.927679, train_loss: 0.239795.
Epoch: 2, accuracy: 0.946987, train_loss: 0.171661.
# 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.

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

इस ट्यूटोरियल ने मल्टी-वर्कर सेटअप के Custom Training Loop वर्कफ़्लो का प्रदर्शन किया है। अन्य विषयों का विस्तृत विवरण बहु-कार्यकर्ता सेटअप के model.fit's guide में उपलब्ध है और सीटीएल पर लागू होता है।

यह सभी देखें

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