সাহায্য Kaggle উপর TensorFlow সঙ্গে গ্রেট বেরিয়ার রিফ রক্ষা চ্যালেঞ্জ যোগদান

Keras এবং MultiWorkerMirroredStrategy সহ কাস্টম প্রশিক্ষণ লুপ

TensorFlow.org এ দেখুন Google Colab-এ চালান GitHub-এ উৎস দেখুন নোটবুক ডাউনলোড করুন

ওভারভিউ

এই টিউটোরিয়ালটি কাস্টম প্রশিক্ষণ লুপ এপিআই, MultiWorkerMirroredStrategy মাধ্যমে বিতরণ করা সঙ্গে বহু-কর্মী প্রশিক্ষণ প্রমান, তাই একটি Keras মডেলের উপর চালানোর জন্য ডিজাইন একক কর্মী অঙ্গীভূতভাবে ন্যূনতম কোড পরিবর্তন সঙ্গে একাধিক শ্রমিকদের কাজ করতে পারেন।

আমরা আমাদের মডেলকে প্রশিক্ষণ দেওয়ার জন্য কাস্টম প্রশিক্ষণ লুপ ব্যবহার করছি কারণ তারা আমাদের নমনীয়তা দেয় এবং প্রশিক্ষণের উপর আরও বেশি নিয়ন্ত্রণ দেয়। তাছাড়া, মডেল এবং প্রশিক্ষণ লুপ ডিবাগ করা সহজ। আরো বিস্তারিত তথ্য পাওয়া যায় গোড়া থেকে একটি প্রশিক্ষণ লুপ লেখা

যদি আপনি খুঁজছেন কিভাবে ব্যবহার করার জন্য MultiWorkerMirroredStrategy keras সঙ্গে model.fit , এই পড়ুন টিউটোরিয়াল পরিবর্তে।

TensorFlow বিতরণ প্রশিক্ষণ বিতরণ নীতি একটি ওভারভিউ জন্য নির্দেশিকা উপলব্ধ আছে TensorFlow গভীরভাবে আগ্রহী তাদের জন্য সমর্থন tf.distribute.Strategy API গুলি।

সেটআপ

প্রথমত, কিছু প্রয়োজনীয় আমদানি।

import json
import os
import sys

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 একটি সহজ মডেল এবং ডেটা সেটটি সেটআপ ফাইল। এই টিউটোরিয়ালটিতে কর্মী-প্রক্রিয়াগুলি দ্বারা এই পাইথন ফাইলটি ব্যবহার করা হবে:

%%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 range [0, 255].
  # You 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)
  return train_dataset

def dataset_fn(global_batch_size, input_context):
  batch_size = input_context.get_per_replica_batch_size(global_batch_size)
  dataset = mnist_dataset(batch_size)
  dataset = dataset.shard(input_context.num_input_pipelines,
                          input_context.input_pipeline_id)
  dataset = dataset.batch(batch_size)
  return dataset

def build_cnn_model():
  return 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)
  ])
Writing 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 যে চেকপয়েন্ট সংরক্ষণ এবং কি একটি নিয়মিত ছাড়াও TensorBoard সারাংশে ফাইল লেখার মত একটু বেশি দায়িত্ব লাগে worker আছে। যেমন একটি কর্মী হিসাবে উল্লেখ করা হয় chief কর্মী, এবং এটি গতানুগতিক যে worker সঙ্গে index 0 প্রধান হিসেবে নিযুক্ত worker (আসলে এই হল কিভাবে tf.distribute.Strategy বাস্তবায়িত হয়)।

  • task বর্তমান কাজের তথ্য প্রদান করে এবং প্রতিটি কর্মী উপর ভিন্ন। এটা তোলে নির্দিষ্ট করে type এবং index যে শ্রমিকের।

এই উদাহরণে, আপনি টাস্ক সেট type করতে "worker" এবং কার্য index থেকে 0 । এই মেশিনটিই প্রথম কর্মী এবং প্রধান কর্মী হিসেবে নিযুক্ত হবেন এবং অন্যদের চেয়ে বেশি কাজ করবেন। নোট যে অন্যান্য মেশিন আছে প্রয়োজন হবে TF_CONFIG পাশাপাশি এনভায়রনমেন্ট ভেরিয়েবল সেট, এবং এটি একই থাকতে হবে cluster বিভিন্ন কাজের অভি কিন্তু type বা কাজের index কি ঐ মেশিনে ভূমিকা আছে উপর নির্ভর করে।

চিত্রণ উদ্দেশ্যে, এই টিউটোরিয়াল দেখায় কিভাবে একজন সেট করতে পারেন TF_CONFIG 2 কর্মচারীদের সাথে localhost । অনুশীলন, ব্যবহারকারীদের বহিরাগত IP ঠিকানা / পোর্ট, এবং সেট একাধিক শ্রমিক তৈরি করবে TF_CONFIG উপযুক্তভাবে প্রতিটি কর্মী উপর।

এই উদাহরণে আপনি, 2 শ্রমিকদের ব্যবহার করবে প্রথম শ্রমিক TF_CONFIG উপরে দেখানো হয়। দ্বিতীয় কর্মীর জন্য আপনাকে সেট হবে tf_config['task']['index']=1

সর্বোপরি, tf_config মাত্র পাইথন একটি স্থানীয় পরিবর্তনশীল। আসলে কনফিগার প্রশিক্ষণ করার জন্য এটি ব্যবহার করতে, এই অভিধান চাহিদা JSON হিসেবে ধারাবাহিকভাবে করা হবে, এবং স্থাপন TF_CONFIG এনভায়রনমেন্ট ভেরিয়েবল।

নোটবুকগুলিতে পরিবেশের পরিবর্তনশীল এবং সাবপ্রসেস

সাবপ্রসেসগুলি তাদের পিতামাতার কাছ থেকে এনভায়রনমেন্ট ভেরিয়েবলের উত্তরাধিকারী হয়। তাই আপনি যদি এই একটি পরিবেশ পরিবর্তনশীল সেট jupyter notebook প্রক্রিয়া:

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

আপনি একটি সাবপ্রসেস থেকে পরিবেশ পরিবর্তনশীল অ্যাক্সেস করতে পারেন:

echo ${GREETINGS}
Hello TensorFlow!

পরের অধ্যায়, আপনি এই ব্যবহার পাস করব TF_CONFIG কর্মী subprocesses করতে। আপনি সত্যিই এইভাবে আপনার কাজগুলি কখনই চালু করবেন না, তবে এই টিউটোরিয়ালের উদ্দেশ্যে এটি যথেষ্ট: একটি ন্যূনতম বহু-কর্মী উদাহরণ প্রদর্শন করার জন্য।

মাল্টিওয়ার্কার মিররড স্ট্র্যাটেজি

মডেল প্রশিক্ষণ করার জন্য, একটি দৃষ্টান্ত ব্যবহার tf.distribute.MultiWorkerMirroredStrategy , যা সব শ্রমিক একে ডিভাইসে মডেলের স্তরগুলোতে সব ভেরিয়েবল কপি তৈরি করে। tf.distribute.Strategy নির্দেশিকা এ কৌশলের সম্পর্কে আরো বিস্তারিত আছে।

strategy = tf.distribute.MultiWorkerMirroredStrategy()
INFO:tensorflow:Single-worker MultiWorkerMirroredStrategy with local_devices = ('/device:CPU:0',), communication = CommunicationImplementation.AUTO
2021-11-23 02:29:16.957442: E tensorflow/stream_executor/cuda/cuda_driver.cc:271] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected
2021-11-23 02:29:16.957748: E tensorflow/stream_executor/cuda/cuda_diagnostics.cc:313] kernel version 470.63.1 does not match DSO version 470.82.0 -- cannot find working devices in this configuration

ব্যবহারের tf.distribute.Strategy.scope যখন আপনার মডেল বিল্ডিং নির্দিষ্ট করার একটি কৌশল ব্যবহার করা উচিত। এই "আপনি রাখে ক্রস প্রতিরূপ প্রসঙ্গ এই কৌশল, যা কৌশল পরিবর্তনশীল বসানো ভালো জিনিস নিয়ন্ত্রণে রাখা হয় মানে-এর জন্য"।

import mnist
with strategy.scope():
  # Model building needs to be within `strategy.scope()`.
  multi_worker_model = mnist.build_cnn_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))
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 0s 0us/step
11501568/11490434 [==============================] - 0s 0us/step

কাস্টম ট্রেনিং লুপ সংজ্ঞায়িত করুন এবং মডেলটিকে প্রশিক্ষণ দিন

একটি অপ্টিমাইজার নির্দিষ্ট করুন

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, cluster_spec):
  return (task_type is None
          or task_type == 'chief'
          or (task_type == 'worker'
              and task_id == 0
              and "chief" not in cluster_spec.as_dict()))

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, cluster_spec):
  dirpath = os.path.dirname(filepath)
  base = os.path.basename(filepath)
  if not _is_chief(task_type, task_id, cluster_spec):
    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)
# We normally don't need to manually instantiate a ClusterSpec, but in this 
# illustrative example we did not set TF_CONFIG before initializing the
# strategy. See the next section for "real-world" usage.
cluster_spec = tf.train.ClusterSpec(tf_config['cluster'])

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,
                                      cluster_spec)
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, cluster_spec):
    tf.io.gfile.rmtree(write_checkpoint_dir)

  epoch.assign_add(1)
  step_in_epoch.assign(0)
2021-11-23 02:29:18.214294: W tensorflow/core/framework/dataset.cc:744] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.
Epoch: 0, accuracy: 0.826228, train_loss: 0.540131.
Epoch: 1, accuracy: 0.937946, train_loss: 0.207413.
Epoch: 2, accuracy: 0.960603, train_loss: 0.137420.

কর্মীদের উপর সম্পূর্ণ কোড সেটআপ

আসলে সঙ্গে চালানোর জন্য MultiWorkerMirroredStrategy আপনি ওয়ার্কার প্রসেস চালানো এবং একটি পাস করতে হবে TF_CONFIG তাদের।

ভালো লেগেছে mnist.py আগে লিখিত ফাইল, এখানে main.py যে একই কোড আমরা এই colab মধ্যে পূর্বে ধাপে ধাপে মাধ্যমে walked ধারণ, আমরা শুধু একটি ফাইলে এটা লেখার করছি যাতে করে শ্রমিকদের প্রত্যেকের এটি চালানোর হবে:

ফাইল: main.py

Writing main.py

ট্রেন এবং মূল্যায়ন

বর্তমান ডিরেক্টরিতে এখন উভয় পাইথন ফাইল রয়েছে:

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 পটভূমিতে প্রক্রিয়া, কারণ এই কর্মী বিনষ্ট করা হবে না। এটি শুরু হওয়ার আগে সমস্ত কর্মীদের জন্য অপেক্ষা করে।

পশ্চাদপটে করা কর্মী প্রক্রিয়ায়, এই নোটবুক আউটপুট মুদ্রণ করতে হবে যাতে &> একটি ফাইলে তার আউটপুট পুননির্দেশনা, যাতে আপনি দেখতে পারেন কি ঘটেছে।

সুতরাং, প্রক্রিয়াটি শুরু হওয়ার জন্য কয়েক সেকেন্ড অপেক্ষা করুন:

import time
time.sleep(20)

এখন পর্যন্ত কর্মীর লগফাইলে কী আউটপুট হয়েছে তা দেখুন:

cat job_0.log
2021-11-23 02:29:29.831748: E tensorflow/stream_executor/cuda/cuda_driver.cc:271] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected
2021-11-23 02:29:29.832003: E tensorflow/stream_executor/cuda/cuda_diagnostics.cc:313] kernel version 470.63.1 does not match DSO version 470.82.0 -- cannot find working devices in this configuration

লগ ফাইল শেষ লাইন বলা উচিত: 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 > /dev/null 2>&1

এখন আপনি যদি প্রথম কর্মী দ্বারা লিখিত লগগুলি পুনরায় পরীক্ষা করেন তবে আপনি দেখতে পাবেন যে এটি সেই মডেলের প্রশিক্ষণে অংশগ্রহণ করেছে:

cat job_0.log
2021-11-23 02:29:29.831748: E tensorflow/stream_executor/cuda/cuda_driver.cc:271] failed call to cuInit: CUDA_ERROR_NO_DEVICE: no CUDA-capable device is detected
2021-11-23 02:29:29.832003: E tensorflow/stream_executor/cuda/cuda_diagnostics.cc:313] kernel version 470.63.1 does not match DSO version 470.82.0 -- cannot find working devices in this configuration
2021-11-23 02:29:50.709898: W tensorflow/core/framework/dataset.cc:744] Input of GeneratorDatasetOp::Dataset will not be optimized because the dataset does not implement the AsGraphDefInternal() method needed to apply optimizations.
Epoch: 0, accuracy: 0.820424, train_loss: 0.575663.
Epoch: 1, accuracy: 0.927344, train_loss: 0.241324.
Epoch: 2, accuracy: 0.953237, train_loss: 0.154762.
# 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 CTLs করার বহু-কর্মী সেটআপ এর এবং প্রযোজ্য।

আরো দেখুন

  1. TensorFlow বিতরণ প্রশিক্ষণ নির্দেশিকা প্রাপ্তিসাধ্য বিতরণ নীতি একটি ওভারভিউ প্রদান করে।
  2. অফিসিয়াল মডেল , যার অনেকগুলোই একাধিক বিতরণ নীতি চালানোর জন্য কনফিগার করা যাবে।
  3. পারফরমেন্স অধ্যায় গাইডে অন্যান্য কৌশল ও বিষয়ে তথ্য প্রদান করে টুলস আপনি আপনার TensorFlow মডেলের কর্মক্ষমতা নিখুত ব্যবহার করতে পারেন।