গুগল I / O মে 18-20 মে! স্থান সংরক্ষণ করুন এবং আপনার সময়সূচীটি এখনই নিবন্ধ করুন

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

টেনসরফ্লো.আর.জে দেখুন গুগল কোলাবে চালান গিটহাবের উত্স দেখুন নোটবুক ডাউনলোড করুন

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

সেটআপ

import tensorflow as tf

import os
import tensorflow_datasets as tfds

টিপিইউ সূচনা

টিপিইউ সাধারণত ক্লাউড টিপিইউ কর্মীদের উপর থাকে যা ব্যবহারকারী অজগর প্রোগ্রাম চালানোর স্থানীয় প্রক্রিয়া থেকে পৃথক। রিমোট ক্লাস্টারের সাথে সংযোগ স্থাপন এবং টিপিইউগুলি শুরু করার জন্য কিছু প্রাথমিককরণ কাজ করা দরকার। মনে রাখবেন যে, tpu আর্গুমেন্ট প্রাপ্ত করতে TPUClusterResolver শুধু Colab জন্য একটি বিশেষ ঠিকানা। আপনি গুগল কম্পিউট ইঞ্জিন (জিসিই) তে চালাচ্ছেন এমন ক্ষেত্রে আপনার পরিবর্তে আপনার ক্লাউডটিপিউয়ের নামে পাস করা উচিত।

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:Initializing the TPU system: grpc://10.240.1.74:8470
INFO:tensorflow:Initializing the TPU system: grpc://10.240.1.74:8470
INFO:tensorflow:Clearing out eager caches
INFO:tensorflow:Clearing out eager caches
INFO:tensorflow:Finished initializing TPU system.
INFO:tensorflow:Finished initializing TPU system.
All devices:  [LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:7', 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:5', 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:3', device_type='TPU'), 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')]

ম্যানুয়াল ডিভাইস স্থাপন

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

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)

বিতরণ কৌশল

বেশিরভাগ সময় ব্যবহারকারীরা ডেটা সমান্তরাল উপায়ে একাধিক টিপিইউতে মডেলটি চালাতে চান। বিতরণ কৌশল হ'ল বিমূর্ততা যা সিপিইউ, জিপিইউ বা টিপিইউগুলিতে মডেলগুলি ড্রাইভ করতে ব্যবহৃত হতে পারে। কেবল বিতরণ কৌশলটি অদলবদল করুন এবং মডেলটি প্রদত্ত ডিভাইসে চালিত হবে। আরও তথ্যের জন্য বিতরণ কৌশল গাইড দেখুন।

প্রথমে, 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)
}

টিপিইউগুলিতে শ্রেণিবদ্ধকরণ

আমরা যেমন প্রাথমিক ধারণাটি শিখেছি, ততই আরও দৃ concrete় উদাহরণ দেখার সময় এসেছে। এই গাইডটি দেখায় যে কীভাবে ক্লাউড tf.distribute.TPUStrategy করতে এবং কেরাস মডেলকে প্রশিক্ষণ দেওয়ার জন্য tf.distribute.TPUStrategy বিতরণ কৌশলটি ব্যবহার করতে হয়।

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

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

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 ব্যবহার করার সময়tf.data.Dataset API এর দক্ষ ব্যবহার গুরুত্বপূর্ণ, কারণ আপনি যদি তাদের পর্যাপ্ত পরিমাণে ডেটা ফিড না করতে পারেন তবে ক্লাউড টিপিইউগুলি ব্যবহার করা অসম্ভব। ডেটাसेट পারফরম্যান্সের বিশদগুলির জন্য ইনপুট পাইপলাইন পারফরম্যান্স গাইড দেখুন।

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

বেশিরভাগ ব্যবহারের ক্ষেত্রে, আপনার ডেটাটি TFRecord ফর্ম্যাটে রূপান্তর করতে এবং এটি পড়তে একটি tf.data.TFRecordDataset ব্যবহার করার tf.data.TFRecordDataset হয়। এটি কীভাবে করা যায় তার বিশদ জানতে টিএফআরকার্ড এবং tf.Example টিউটোরিয়াল দেখুন। এটি অবশ্য কোনও হার্ড প্রয়োজন নয় এবং আপনি যদি পছন্দ করেন তবে আপনি অন্যান্য ডেটাसेट পাঠক ( FixedLengthRecordDataset বা TextLineDataset ডেটা TextLineDataset ) ব্যবহার করতে পারেন।

ছোট ডেটাসেটগুলি tf.data.Dataset.cache ব্যবহার করে tf.data.Dataset.cache পুরোপুরি লোড করা যায়।

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

এমএনআইএসটি প্রশিক্ষণ ডেটার একটি অনুলিপি পেতে এখানে আপনার tensorflow_datasets মডিউলটি ব্যবহার করা উচিত। দ্রষ্টব্য যে try_gcs একটি সর্বজনীন জিসিএস বালতিতে উপলব্ধ একটি অনুলিপি ব্যবহার করতে নির্দিষ্ট করা আছে। আপনি যদি এটি নির্দিষ্ট না করেন তবে টিপিইউ ডাউনলোড করা ডেটা অ্যাক্সেস করতে সক্ষম হবে না।

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)

  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 to have a
  # infinite dataset for training is to avoid the potential last partial batch
  # in each epoch, so users 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

কেরাস উচ্চ স্তরের এপিআই ব্যবহার করে একটি মডেলকে প্রশিক্ষণ দিন

আপনি কেবল কেরাস ফিট / কম্পাইল এপিআই দিয়ে কোনও মডেলকে প্রশিক্ষণ দিতে পারেন। এখানে কিছুই নমনীয় নির্দিষ্ট আপনি নীচের যদি আপনি একাধিক জিপিইউ ছিল এবং যেখানে একটি ব্যবহার করে একই কোড লিখতে হবে MirroredStrategy বদলে TPUStrategy । আরও জানতে, কেরাস টিউটোরিয়াল দিয়ে বিতরণ প্রশিক্ষণ দেখুন check

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 [==============================] - 19s 38ms/step - loss: 0.3196 - sparse_categorical_accuracy: 0.8996 - val_loss: 0.0467 - val_sparse_categorical_accuracy: 0.9855
Epoch 2/5
300/300 [==============================] - 7s 25ms/step - loss: 0.0381 - sparse_categorical_accuracy: 0.9878 - val_loss: 0.0379 - val_sparse_categorical_accuracy: 0.9885
Epoch 3/5
300/300 [==============================] - 8s 26ms/step - loss: 0.0213 - sparse_categorical_accuracy: 0.9933 - val_loss: 0.0366 - val_sparse_categorical_accuracy: 0.9892
Epoch 4/5
300/300 [==============================] - 8s 25ms/step - loss: 0.0130 - sparse_categorical_accuracy: 0.9961 - val_loss: 0.0327 - val_sparse_categorical_accuracy: 0.9902
Epoch 5/5
300/300 [==============================] - 8s 25ms/step - loss: 0.0083 - sparse_categorical_accuracy: 0.9975 - val_loss: 0.0465 - val_sparse_categorical_accuracy: 0.9885
<tensorflow.python.keras.callbacks.History at 0x7fc0906c90b8>

পাইথন ওভারহেড হ্রাস করতে এবং আপনার Model.compile কার্যকারিতা সর্বাধিক করে তোলার জন্য পরীক্ষামূলক experimental_steps_per_execution যুক্তিটি Model.compile চেষ্টা করে দেখুন। এখানে এটি থ্রুপুট প্রায় 50% বৃদ্ধি করে:

with strategy.scope():
  model = create_model()
  model.compile(optimizer='adam',
                # Anything between 2 and `steps_per_epoch` could help here.
                experimental_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)
WARNING:tensorflow:The argument `steps_per_execution` is no longer experimental. Pass `steps_per_execution` instead of `experimental_steps_per_execution`.
WARNING:tensorflow:The argument `steps_per_execution` is no longer experimental. Pass `steps_per_execution` instead of `experimental_steps_per_execution`.
Epoch 1/5
300/300 [==============================] - 14s 46ms/step - loss: 0.2399 - sparse_categorical_accuracy: 0.9279 - val_loss: 0.0510 - val_sparse_categorical_accuracy: 0.9838
Epoch 2/5
300/300 [==============================] - 5s 15ms/step - loss: 0.0406 - sparse_categorical_accuracy: 0.9876 - val_loss: 0.0409 - val_sparse_categorical_accuracy: 0.9882
Epoch 3/5
300/300 [==============================] - 5s 15ms/step - loss: 0.0203 - sparse_categorical_accuracy: 0.9936 - val_loss: 0.0394 - val_sparse_categorical_accuracy: 0.9879
Epoch 4/5
300/300 [==============================] - 5s 15ms/step - loss: 0.0132 - sparse_categorical_accuracy: 0.9959 - val_loss: 0.0410 - val_sparse_categorical_accuracy: 0.9879
Epoch 5/5
300/300 [==============================] - 5s 15ms/step - loss: 0.0140 - sparse_categorical_accuracy: 0.9953 - val_loss: 0.0508 - val_sparse_categorical_accuracy: 0.9863
<tensorflow.python.keras.callbacks.History at 0x7fbc743646d8>

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

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

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

# Create the model, optimizer and metrics inside 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-2f075cabff81>: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-2f075cabff81>: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

তারপরে প্রশিক্ষণ লুপ চালান run

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.1237, accuracy: 96.17%
Epoch: 1/5
Current step: 600, training loss: 0.0333, accuracy: 98.98%
Epoch: 2/5
Current step: 900, training loss: 0.0185, accuracy: 99.37%
Epoch: 3/5
Current step: 1200, training loss: 0.0135, accuracy: 99.54%
Epoch: 4/5
Current step: 1500, training loss: 0.0092, accuracy: 99.7%

tf.function মধ্যে একাধিক পদক্ষেপের দ্বারা কর্মক্ষমতা উন্নত করা

tf.function মধ্যে একাধিক পদক্ষেপ চালিয়ে পারফরম্যান্সটি উন্নত করা tf.functiontf.range ভিতরে tf.function দিয়ে strategy.run কল tf.range কলটি মোড়ানোর মাধ্যমে এটি অর্জন করা tf.function , অটোগ্রাফ এটিকে tf.while_loop কর্মীর tf.while_loop . tf.while_loop এ রূপান্তর করবে।

যদিও আরও ভাল পারফরম্যান্সের সাথে, tf.function ভিতরে একক ধাপের সাথে তুলনা করা tf.functiontf.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.009, accuracy: 99.71%

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