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

টিপিইউ ব্যবহার করুন

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

রানটাইম> পরিবর্তন রানটাইম টাইপ> হার্ডওয়্যার বেগবর্ধক> নমনীয়: আপনি এই Colab নোটবুক চালানো, নিশ্চিত করুন যে আপনার হার্ডওয়ার বেগবর্ধক আপনার নোটবুক পরীক্ষা সেটিংস দ্বারা একটি নমনীয় তা নিশ্চিত করুন।

সেটআপ

import tensorflow as tf

import os
import tensorflow_datasets as tfds
/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/requests/__init__.py:104: RequestsDependencyWarning: urllib3 (1.26.7) or chardet (2.3.0)/charset_normalizer (2.0.9) doesn't match a supported version!
  RequestsDependencyWarning)

TPU সূচনা

TPU গুলি সাধারণত ক্লাউড TPU কর্মী, যা ব্যবহারকারীর পাইথন প্রোগ্রাম চালানো স্থানীয় প্রক্রিয়া থেকে আলাদা। এইভাবে, আপনাকে রিমোট ক্লাস্টারের সাথে সংযোগ করতে এবং TPU গুলি শুরু করতে কিছু প্রাথমিক কাজ করতে হবে। মনে রাখবেন যে, tpu আর্গুমেন্ট প্রাপ্ত করতে tf.distribute.cluster_resolver.TPUClusterResolver শুধু Colab জন্য একটি বিশেষ ঠিকানা। আপনি যদি Google Compute Engine (GCE) তে আপনার কোড চালান, তাহলে আপনার পরিবর্তে আপনার Cloud TPU-এর নামে পাস করা উচিত।

resolver = tf.distribute.cluster_resolver.TPUClusterResolver(tpu='')
tf.config.experimental_connect_to_cluster(resolver)
# This is the TPU initialization code that has to be at the beginning.
tf.tpu.experimental.initialize_tpu_system(resolver)
print("All devices: ", tf.config.list_logical_devices('TPU'))
INFO:tensorflow:Clearing out eager caches
INFO:tensorflow:Clearing out eager caches
INFO:tensorflow:Initializing the TPU system: grpc://10.240.1.74:8470
INFO:tensorflow:Initializing the TPU system: grpc://10.240.1.74:8470
INFO:tensorflow:Finished initializing TPU system.
INFO:tensorflow:Finished initializing TPU system.
All devices:  [LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:0', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:1', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:2', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:3', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:4', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:5', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:6', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:7', device_type='TPU')]

ম্যানুয়াল ডিভাইস বসানো

TPU আরম্ভ করার পরে, আপনি একটি একক TPU ডিভাইসে গণনা স্থাপন করতে ম্যানুয়াল ডিভাইস বসানো ব্যবহার করতে পারেন:

a = tf.constant([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
b = tf.constant([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]])

with tf.device('/TPU:0'):
  c = tf.matmul(a, b)

print("c device: ", c.device)
print(c)
c device:  /job:worker/replica:0/task:0/device:TPU:0
tf.Tensor(
[[22. 28.]
 [49. 64.]], shape=(2, 2), dtype=float32)

বিতরণ কৌশল

সাধারণত আপনি ডেটা-সমান্তরাল উপায়ে একাধিক TPU-তে আপনার মডেল চালান। একাধিক TPUs (বা অন্যান্য ত্বরণকারী) তে আপনার মডেল বিতরণ করতে, TensorFlow বেশ কিছু বিতরণ কৌশল অফার করে। আপনি আপনার বিতরণ কৌশল প্রতিস্থাপন করতে পারেন এবং মডেলটি যে কোনো (TPU) ডিভাইসে চলবে। পরীক্ষা করে দেখুন বন্টন কৌশল নির্দেশিকা আরও তথ্যের জন্য।

এই প্রদর্শন করতে, একটি তৈরি tf.distribute.TPUStrategy বস্তু:

strategy = tf.distribute.TPUStrategy(resolver)
INFO:tensorflow:Found TPU system:
INFO:tensorflow:Found TPU system:
INFO:tensorflow:*** Num TPU Cores: 8
INFO:tensorflow:*** Num TPU Cores: 8
INFO:tensorflow:*** Num TPU Workers: 1
INFO:tensorflow:*** Num TPU Workers: 1
INFO:tensorflow:*** Num TPU Cores Per Worker: 8
INFO:tensorflow:*** Num TPU Cores Per Worker: 8
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:localhost/replica:0/task:0/device:CPU:0, CPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:localhost/replica:0/task:0/device:CPU:0, CPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:CPU:0, CPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:CPU:0, CPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:0, TPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:0, TPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:1, TPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:1, TPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:2, TPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:2, TPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:3, TPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:3, TPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:4, TPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:4, TPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:5, TPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:5, TPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:6, TPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:6, TPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:7, TPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU:7, TPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU_SYSTEM:0, TPU_SYSTEM, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:TPU_SYSTEM:0, TPU_SYSTEM, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:XLA_CPU:0, XLA_CPU, 0, 0)
INFO:tensorflow:*** Available Device: _DeviceAttributes(/job:worker/replica:0/task:0/device:XLA_CPU:0, XLA_CPU, 0, 0)

তাই এটি সব নমনীয় কোর চালানো যেতে পারে একটি গুনতি প্রতিলিপি করার জন্য, আপনাকে তা পাস করতে পারেন strategy.run API- টি। নীচে একটি উদাহরণ যে শো সব কোর একই ইনপুট গ্রহণ করা হয় (a, b) এবং স্বাধীনভাবে প্রতিটি কোর উপর ম্যাট্রিক্স গুণ অনুষ্ঠানে যোগ দেন। আউটপুট সব প্রতিলিপি থেকে মান হবে.

@tf.function
def matmul_fn(x, y):
  z = tf.matmul(x, y)
  return z

z = strategy.run(matmul_fn, args=(a, b))
print(z)
PerReplica:{
  0: tf.Tensor(
[[22. 28.]
 [49. 64.]], shape=(2, 2), dtype=float32),
  1: tf.Tensor(
[[22. 28.]
 [49. 64.]], shape=(2, 2), dtype=float32),
  2: tf.Tensor(
[[22. 28.]
 [49. 64.]], shape=(2, 2), dtype=float32),
  3: tf.Tensor(
[[22. 28.]
 [49. 64.]], shape=(2, 2), dtype=float32),
  4: tf.Tensor(
[[22. 28.]
 [49. 64.]], shape=(2, 2), dtype=float32),
  5: tf.Tensor(
[[22. 28.]
 [49. 64.]], shape=(2, 2), dtype=float32),
  6: tf.Tensor(
[[22. 28.]
 [49. 64.]], shape=(2, 2), dtype=float32),
  7: tf.Tensor(
[[22. 28.]
 [49. 64.]], shape=(2, 2), dtype=float32)
}

TPU-তে শ্রেণীবিভাগ

মৌলিক ধারণাগুলি কভার করার পরে, একটি আরও সুনির্দিষ্ট উদাহরণ বিবেচনা করুন। এই বিভাগে বন্টন strategy- কীভাবে ব্যবহার করবেন তা প্রমান tf.distribute.TPUStrategy একটি মেঘ নমনীয় একটি Keras মডেল প্রশিক্ষণ -to।

একটি কেরাস মডেল সংজ্ঞায়িত করুন

একটি একটি সংজ্ঞা দিয়ে শুরু করুন Sequential Keras ব্যবহার MNIST ডেটা সেটটি ছবিটি শ্রেণীবিভাগ জন্য Keras মডেল। আপনি যদি CPUs বা GPU তে প্রশিক্ষণ নেন তবে আপনি যা ব্যবহার করবেন তার থেকে এটি আলাদা নয়। লক্ষ্য করুন Keras মডেল সৃষ্টি চাহিদা ভিতরে হতে strategy.scope , তাই ভেরিয়েবল প্রতিটি নমনীয় ডিভাইসে তৈরি করা যায়। কোডের অন্যান্য অংশগুলি কৌশলের সুযোগের মধ্যে থাকা আবশ্যক নয়।

def create_model():
  return tf.keras.Sequential(
      [tf.keras.layers.Conv2D(256, 3, activation='relu', input_shape=(28, 28, 1)),
       tf.keras.layers.Conv2D(256, 3, activation='relu'),
       tf.keras.layers.Flatten(),
       tf.keras.layers.Dense(256, activation='relu'),
       tf.keras.layers.Dense(128, activation='relu'),
       tf.keras.layers.Dense(10)])

ডেটাসেট লোড করুন

দক্ষ ব্যবহার tf.data.Dataset এপিআই সমালোচনামূলক যখন একটি মেঘ নমনীয় ব্যবহার যেমন মেঘ TPUs ব্যবহার করতে যদি না আপনি তাদের ডেটা দ্রুত যথেষ্ট খাওয়াতে পারি অসম্ভব হয়। আপনি ডেটা সেটটি কর্মক্ষমতা সম্পর্কে আরও জানতে পারেন ইনপুট পাইপলাইন কর্মক্ষমতা গাইড

সব কিন্তু সবচেয়ে সহজ পরীক্ষা-নিরীক্ষা (ব্যবহার করার জন্য tf.data.Dataset.from_tensor_slices বা অন্যান্য ইন-গ্রাফ তথ্য), আপনি সঞ্চয় করতে সমস্ত ডেটা ফাইল Google Cloud Storage এ ডেটা সেটটি (GCS) বাকেট দ্বারা পড়া প্রয়োজন।

সবচেয়ে ব্যবহারের ক্ষেত্রে, এটি আপনার ডেটা রূপান্তর করতে সুপারিশ করা হয় TFRecord একটি ব্যবহার বিন্যাস এবং tf.data.TFRecordDataset এটা পড়তে। পরীক্ষা করে দেখুন TFRecord এবং tf.Example টিউটোরিয়াল কিভাবে এই করতে হবে সেই বিষয়ে বিস্তারিত জানার জন্য। এ থেকে পাওয়া শক্ত প্রয়োজন হয় না এবং আপনি এই ধরনের অন্যান্য ডেটা সেটটি পাঠক, ব্যবহার করতে পারেন tf.data.FixedLengthRecordDataset বা tf.data.TextLineDataset

ব্যবহার করে আপনি মেমরিতে সমগ্র ছোট ডেটাসেট লোড করতে পারেন tf.data.Dataset.cache

ব্যবহার করা ডেটা বিন্যাস নির্বিশেষে, এটি দৃঢ়ভাবে সুপারিশ করা হয় যে আপনি 100MB এর অর্ডারে বড় ফাইলগুলি ব্যবহার করুন৷ এই নেটওয়ার্ক সেটিংয়ে এটি বিশেষভাবে গুরুত্বপূর্ণ, কারণ একটি ফাইল খোলার ওভারহেড উল্লেখযোগ্যভাবে বেশি।

হিসাবে নিচের কোড প্রদর্শিত, আপনি ব্যবহার করা উচিত tensorflow_datasets MNIST প্রশিক্ষণ ও পরীক্ষা ডেটার একটি অনুলিপি পেতে মডিউল। লক্ষ্য করুন try_gcs একটি কপি করে একটি পাবলিক GCS বালতি পাওয়া যায় ব্যবহার করতে নির্দিষ্ট করা হয়েছে। আপনি যদি এটি নির্দিষ্ট না করেন, TPU ডাউনলোড করা ডেটা অ্যাক্সেস করতে সক্ষম হবে না।

def get_dataset(batch_size, is_training=True):
  split = 'train' if is_training else 'test'
  dataset, info = tfds.load(name='mnist', split=split, with_info=True,
                            as_supervised=True, try_gcs=True)

  # Normalize the input data.
  def scale(image, label):
    image = tf.cast(image, tf.float32)
    image /= 255.0
    return image, label

  dataset = dataset.map(scale)

  # Only shuffle and repeat the dataset in training. The advantage of having an
  # infinite dataset for training is to avoid the potential last partial batch
  # in each epoch, so that you don't need to think about scaling the gradients
  # based on the actual batch size.
  if is_training:
    dataset = dataset.shuffle(10000)
    dataset = dataset.repeat()

  dataset = dataset.batch(batch_size)

  return dataset

কেরাস উচ্চ-স্তরের API ব্যবহার করে মডেলকে প্রশিক্ষণ দিন

আপনি Keras সঙ্গে আপনার মডেল শেখাতে পারেন fit এবং compile API গুলি। কিছুই নমনীয়-নির্দিষ্ট এই ধাপে আপনি যেন আপনি একাধিক জিপিইউ এবং ব্যবহার করা হয়েছে কোড লিখতে হয় MirroredStrategy পরিবর্তে TPUStrategy । আপনি আরও জানতে পারেন Keras সঙ্গে বন্টিত প্রশিক্ষণ টিউটোরিয়াল।

with strategy.scope():
  model = create_model()
  model.compile(optimizer='adam',
                loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
                metrics=['sparse_categorical_accuracy'])

batch_size = 200
steps_per_epoch = 60000 // batch_size
validation_steps = 10000 // batch_size

train_dataset = get_dataset(batch_size, is_training=True)
test_dataset = get_dataset(batch_size, is_training=False)

model.fit(train_dataset,
          epochs=5,
          steps_per_epoch=steps_per_epoch,
          validation_data=test_dataset, 
          validation_steps=validation_steps)
Epoch 1/5
300/300 [==============================] - 18s 32ms/step - loss: 0.1291 - sparse_categorical_accuracy: 0.9590 - val_loss: 0.0392 - val_sparse_categorical_accuracy: 0.9879
Epoch 2/5
300/300 [==============================] - 6s 21ms/step - loss: 0.0338 - sparse_categorical_accuracy: 0.9894 - val_loss: 0.0381 - val_sparse_categorical_accuracy: 0.9878
Epoch 3/5
300/300 [==============================] - 6s 21ms/step - loss: 0.0171 - sparse_categorical_accuracy: 0.9942 - val_loss: 0.0576 - val_sparse_categorical_accuracy: 0.9856
Epoch 4/5
300/300 [==============================] - 6s 21ms/step - loss: 0.0132 - sparse_categorical_accuracy: 0.9956 - val_loss: 0.0490 - val_sparse_categorical_accuracy: 0.9869
Epoch 5/5
300/300 [==============================] - 6s 21ms/step - loss: 0.0106 - sparse_categorical_accuracy: 0.9967 - val_loss: 0.0426 - val_sparse_categorical_accuracy: 0.9879
<keras.callbacks.History at 0x7fecb03211d0>

পাইথন ভার হ্রাস করা সম্ভব এবং আপনার নমনীয় কর্মক্ষমতা পূর্ণবিস্তার করার জন্য, argument- মধ্যে পাস steps_per_execution -to Model.compile । এই উদাহরণে, এটি প্রায় 50% দ্বারা থ্রুপুট বৃদ্ধি করে:

with strategy.scope():
  model = create_model()
  model.compile(optimizer='adam',
                # Anything between 2 and `steps_per_epoch` could help here.
                steps_per_execution = 50,
                loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
                metrics=['sparse_categorical_accuracy'])

model.fit(train_dataset,
          epochs=5,
          steps_per_epoch=steps_per_epoch,
          validation_data=test_dataset,
          validation_steps=validation_steps)
Epoch 1/5
300/300 [==============================] - 13s 42ms/step - loss: 0.1402 - sparse_categorical_accuracy: 0.9559 - val_loss: 0.0441 - val_sparse_categorical_accuracy: 0.9850
Epoch 2/5
300/300 [==============================] - 3s 10ms/step - loss: 0.0331 - sparse_categorical_accuracy: 0.9894 - val_loss: 0.0419 - val_sparse_categorical_accuracy: 0.9869
Epoch 3/5
300/300 [==============================] - 3s 10ms/step - loss: 0.0186 - sparse_categorical_accuracy: 0.9938 - val_loss: 0.0487 - val_sparse_categorical_accuracy: 0.9858
Epoch 4/5
300/300 [==============================] - 3s 10ms/step - loss: 0.0124 - sparse_categorical_accuracy: 0.9959 - val_loss: 0.0484 - val_sparse_categorical_accuracy: 0.9890
Epoch 5/5
300/300 [==============================] - 3s 10ms/step - loss: 0.0100 - sparse_categorical_accuracy: 0.9966 - val_loss: 0.0466 - val_sparse_categorical_accuracy: 0.9888
<keras.callbacks.History at 0x7fecb0321c18>

একটি কাস্টম প্রশিক্ষণ লুপ ব্যবহার করে মডেল প্রশিক্ষণ

আপনি নির্মাণ এবং ব্যবহার করে আপনার মডেল শেখাতে পারেন tf.function এবং tf.distribute সরাসরি API গুলি। আপনি ব্যবহার করতে পারেন strategy.experimental_distribute_datasets_from_function এপিআই ডেটা সেটটি একটি ডেটাসেটের ফাংশন দেওয়া বিতরণ করতে। উল্লেখ্য যে নীচের উদাহরণে ডেটাসেটে পাস করা ব্যাচের আকার হল বিশ্বব্যাপী ব্যাচের আকারের পরিবর্তে প্রতি-প্রতিলিপি ব্যাচের আকার। আরো জানতে, খুঁজে বার করো tf.distribute.Strategy সঙ্গে কাস্টম প্রশিক্ষণ টিউটোরিয়াল।

প্রথমে, মডেল, ডেটাসেট এবং tf. ফাংশন তৈরি করুন:

# Create the model, optimizer and metrics inside the strategy scope, so that the
# variables can be mirrored on each device.
with strategy.scope():
  model = create_model()
  optimizer = tf.keras.optimizers.Adam()
  training_loss = tf.keras.metrics.Mean('training_loss', dtype=tf.float32)
  training_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(
      'training_accuracy', dtype=tf.float32)

# Calculate per replica batch size, and distribute the datasets on each TPU
# worker.
per_replica_batch_size = batch_size // strategy.num_replicas_in_sync

train_dataset = strategy.experimental_distribute_datasets_from_function(
    lambda _: get_dataset(per_replica_batch_size, is_training=True))

@tf.function
def train_step(iterator):
  """The step function for one training step."""

  def step_fn(inputs):
    """The computation to run on each TPU device."""
    images, labels = inputs
    with tf.GradientTape() as tape:
      logits = model(images, training=True)
      loss = tf.keras.losses.sparse_categorical_crossentropy(
          labels, logits, from_logits=True)
      loss = tf.nn.compute_average_loss(loss, global_batch_size=batch_size)
    grads = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(list(zip(grads, model.trainable_variables)))
    training_loss.update_state(loss * strategy.num_replicas_in_sync)
    training_accuracy.update_state(labels, logits)

  strategy.run(step_fn, args=(next(iterator),))
WARNING:tensorflow:From <ipython-input-1-5625c2a14441>:15: StrategyBase.experimental_distribute_datasets_from_function (from tensorflow.python.distribute.distribute_lib) is deprecated and will be removed in a future version.
Instructions for updating:
rename to distribute_datasets_from_function
WARNING:tensorflow:From <ipython-input-1-5625c2a14441>:15: StrategyBase.experimental_distribute_datasets_from_function (from tensorflow.python.distribute.distribute_lib) is deprecated and will be removed in a future version.
Instructions for updating:
rename to distribute_datasets_from_function

তারপর, প্রশিক্ষণ লুপ চালান:

steps_per_eval = 10000 // batch_size

train_iterator = iter(train_dataset)
for epoch in range(5):
  print('Epoch: {}/5'.format(epoch))

  for step in range(steps_per_epoch):
    train_step(train_iterator)
  print('Current step: {}, training loss: {}, accuracy: {}%'.format(
      optimizer.iterations.numpy(),
      round(float(training_loss.result()), 4),
      round(float(training_accuracy.result()) * 100, 2)))
  training_loss.reset_states()
  training_accuracy.reset_states()
Epoch: 0/5
Current step: 300, training loss: 0.1292, accuracy: 95.95%
Epoch: 1/5
Current step: 600, training loss: 0.0322, accuracy: 98.99%
Epoch: 2/5
Current step: 900, training loss: 0.0179, accuracy: 99.44%
Epoch: 3/5
Current step: 1200, training loss: 0.014, accuracy: 99.49%
Epoch: 4/5
Current step: 1500, training loss: 0.0109, accuracy: 99.63%

ভিতরে একাধিক পদক্ষেপ সঙ্গে উন্নতি কর্মক্ষমতা tf.function

আপনি একটি মধ্যে একাধিক পদক্ষেপ দৌড়ানো দ্বারা কর্মক্ষমতা বৃদ্ধি করা সম্ভব tf.function । এই মোড়কে করে এটা করা যায় strategy.run একটি সহ কল tf.range ভিতরে tf.function এবং অটোগ্রাফ একটি এটি রূপান্তর করবে tf.while_loop নমনীয় কর্মী উপর।

উন্নত পারফরম্যান্সের পরও সেখানে এই পদ্ধতি ভিতরে একক পদক্ষেপ চলমান তুলনায় সঙ্গে tradeoffs হয় tf.function । একটি একাধিক পদক্ষেপ দৌড়ানো tf.function কম নমনীয়-তুমি কিছু সাগ্রহে চালাতে না পারেন বা পদক্ষেপের মধ্যে অবাধ পাইথন কোড।

@tf.function
def train_multiple_steps(iterator, steps):
  """The step function for one training step."""

  def step_fn(inputs):
    """The computation to run on each TPU device."""
    images, labels = inputs
    with tf.GradientTape() as tape:
      logits = model(images, training=True)
      loss = tf.keras.losses.sparse_categorical_crossentropy(
          labels, logits, from_logits=True)
      loss = tf.nn.compute_average_loss(loss, global_batch_size=batch_size)
    grads = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(list(zip(grads, model.trainable_variables)))
    training_loss.update_state(loss * strategy.num_replicas_in_sync)
    training_accuracy.update_state(labels, logits)

  for _ in tf.range(steps):
    strategy.run(step_fn, args=(next(iterator),))

# Convert `steps_per_epoch` to `tf.Tensor` so the `tf.function` won't get 
# retraced if the value changes.
train_multiple_steps(train_iterator, tf.convert_to_tensor(steps_per_epoch))

print('Current step: {}, training loss: {}, accuracy: {}%'.format(
      optimizer.iterations.numpy(),
      round(float(training_loss.result()), 4),
      round(float(training_accuracy.result()) * 100, 2)))
Current step: 1800, training loss: 0.0076, accuracy: 99.74%

পরবর্তী পদক্ষেপ