टीपीयू का प्रयोग करें

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

रनटाइम> बदलें क्रम प्रकार> हार्डवेयर त्वरक> TPU: इससे पहले कि आप इस Colab नोटबुक चलाने के लिए, सुनिश्चित करें कि आपके हार्डवेयर त्वरक अपनी नोटबुक सेटिंग्स की जाँच करके एक TPU है या नहीं।

सेट अप

import tensorflow as tf

import os
import tensorflow_datasets as tfds
/home/kbuilder/.local/lib/python3.6/site-packages/requests/__init__.py:104: RequestsDependencyWarning: urllib3 (1.26.6) or chardet (2.3.0)/charset_normalizer (2.0.4) doesn't match a supported version!
  RequestsDependencyWarning)

टीपीयू आरंभीकरण

टीपीयू आमतौर पर क्लाउड टीपीयू कार्यकर्ता होते हैं, जो उपयोगकर्ता के पायथन प्रोग्राम को चलाने वाली स्थानीय प्रक्रिया से अलग होते हैं। इस प्रकार, आपको दूरस्थ क्लस्टर से कनेक्ट करने और 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.2:8470
INFO:tensorflow:Initializing the TPU system: grpc://10.240.1.2: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')]

मैनुअल डिवाइस प्लेसमेंट

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

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 (या अन्य त्वरक) पर वितरित करने के लिए, TensorFlow कई वितरण रणनीतियाँ प्रदान करता है। आप अपनी वितरण रणनीति को बदल सकते हैं और मॉडल किसी दिए गए (टीपीयू) डिवाइस पर चलेगा। चेक वितरण रणनीति गाइड और जानकारी के लिए।

इस प्रदर्शन करने के लिए, एक बनाने 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)

तो यह सब TPU कोर में चला सकते हैं एक अभिकलन को दोहराने के लिए, आप इसे में पारित कर सकते हैं strategy.run एपीआई। नीचे एक उदाहरण है कि शो के सभी कोर एक ही आदानों प्राप्त है (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)
}

टीपीयू पर वर्गीकरण

बुनियादी अवधारणाओं को कवर करने के बाद, एक अधिक ठोस उदाहरण पर विचार करें। यह खंड वितरण रणनीति- उपयोग करने के लिए कैसे प्रदर्शित करता है कि tf.distribute.TPUStrategy एक बादल TPU पर एक Keras मॉडल को प्रशिक्षित करने वाली।

केरस मॉडल को परिभाषित करें

एक की एक परिभाषा के साथ शुरू करो Sequential Keras का उपयोग कर MNIST डाटासेट पर छवि वर्गीकरण के लिए Keras मॉडल। यदि आप सीपीयू या जीपीयू पर प्रशिक्षण ले रहे थे तो यह आपके द्वारा उपयोग किए जाने वाले कार्यों से अलग नहीं है। ध्यान दें कि Keras मॉडल बनाने की जरूरत के अंदर होने की strategy.scope , तो चर प्रत्येक TPU डिवाइस पर बनाया जा सकता है। कोड के अन्य भागों का रणनीति के दायरे में होना आवश्यक नहीं है।

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 एपीआई महत्वपूर्ण जब, एक बादल TPU का उपयोग कर के रूप में यह बादल tpus उपयोग करने के लिए जब तक आप उन्हें डेटा जल्दी से पर्याप्त फ़ीड कर सकते हैं असंभव है। आप में डाटासेट प्रदर्शन के बारे में अधिक सीख सकते हैं इनपुट पाइपलाइन प्रदर्शन गाइड

सभी लेकिन सबसे सरल प्रयोग (प्रयोग करने के लिए tf.data.Dataset.from_tensor_slices या अन्य में ग्राफ डेटा), आप स्टोर करने के लिए सभी डेटा फ़ाइलें Google मेघ संग्रहण में डेटासेट (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

केरस उच्च-स्तरीय एपीआई का उपयोग करके मॉडल को प्रशिक्षित करें

आप Keras के साथ अपने मॉडल प्रशिक्षित कर सकते हैं fit और compile एपीआई। कुछ भी TPU विशेष इस में कदम-आप जैसे कि तुम mutliple GPUs और एक उपयोग कर रहे थे कोड लिखने है 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 [==============================] - 19s 35ms/step - loss: 0.1352 - sparse_categorical_accuracy: 0.9583 - val_loss: 0.0404 - val_sparse_categorical_accuracy: 0.9863
Epoch 2/5
300/300 [==============================] - 6s 21ms/step - loss: 0.0346 - sparse_categorical_accuracy: 0.9893 - val_loss: 0.0376 - val_sparse_categorical_accuracy: 0.9882
Epoch 3/5
300/300 [==============================] - 7s 22ms/step - loss: 0.0199 - sparse_categorical_accuracy: 0.9934 - val_loss: 0.0432 - val_sparse_categorical_accuracy: 0.9872
Epoch 4/5
300/300 [==============================] - 6s 21ms/step - loss: 0.0132 - sparse_categorical_accuracy: 0.9957 - val_loss: 0.0475 - val_sparse_categorical_accuracy: 0.9870
Epoch 5/5
300/300 [==============================] - 6s 21ms/step - loss: 0.0100 - sparse_categorical_accuracy: 0.9970 - val_loss: 0.0443 - val_sparse_categorical_accuracy: 0.9877
<keras.callbacks.History at 0x7faf8829f278>

अजगर भूमि के ऊपर कम करने और अपने TPU के प्रदर्शन को अधिकतम करने के लिए, argument- में पारित 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.
                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 43ms/step - loss: 0.1405 - sparse_categorical_accuracy: 0.9571 - val_loss: 0.0438 - val_sparse_categorical_accuracy: 0.9860
Epoch 2/5
300/300 [==============================] - 3s 10ms/step - loss: 0.0337 - sparse_categorical_accuracy: 0.9890 - val_loss: 0.0503 - val_sparse_categorical_accuracy: 0.9847
Epoch 3/5
300/300 [==============================] - 3s 10ms/step - loss: 0.0170 - sparse_categorical_accuracy: 0.9947 - val_loss: 0.0448 - val_sparse_categorical_accuracy: 0.9884
Epoch 4/5
300/300 [==============================] - 3s 10ms/step - loss: 0.0137 - sparse_categorical_accuracy: 0.9956 - val_loss: 0.0362 - val_sparse_categorical_accuracy: 0.9903
Epoch 5/5
300/300 [==============================] - 3s 10ms/step - loss: 0.0090 - sparse_categorical_accuracy: 0.9971 - val_loss: 0.0458 - val_sparse_categorical_accuracy: 0.9880
<keras.callbacks.History at 0x7fae1054f908>

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

तुम भी बना सकते हैं और का उपयोग कर अपने मॉडल प्रशिक्षित कर सकते हैं tf.function और tf.distribute सीधे एपीआई। आप उपयोग कर सकते हैं strategy.experimental_distribute_datasets_from_function एपीआई डाटासेट एक डाटासेट समारोह को देखते हुए वितरित करने के लिए। ध्यान दें कि डेटासेट में पारित बैच आकार के नीचे के उदाहरण में वैश्विक बैच आकार के बजाय प्रति-प्रतिकृति बैच आकार है। अधिक जानकारी के लिए बाहर की जाँच tf.distribute.Strategy के साथ कस्टम प्रशिक्षण ट्यूटोरियल।

सबसे पहले, मॉडल, डेटासेट और tf.functions बनाएं:

# 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.1352, accuracy: 95.85%
Epoch: 1/5
Current step: 600, training loss: 0.0355, accuracy: 98.86%
Epoch: 2/5
Current step: 900, training loss: 0.0194, accuracy: 99.37%
Epoch: 3/5
Current step: 1200, training loss: 0.0127, accuracy: 99.6%
Epoch: 4/5
Current step: 1500, training loss: 0.0111, accuracy: 99.65%

अंदर कई चरणों के साथ प्रदर्शन सुधारना tf.function

तुम एक में एक से अधिक चरणों चलाकर प्रदर्शन में सुधार कर सकते हैं tf.function । यह लपेटकर द्वारा हासिल की है strategy.run एक साथ कॉल tf.range अंदर tf.function , और हस्ताक्षर एक करने के लिए इसे परिवर्तित कर देंगे tf.while_loop TPU कार्यकर्ता पर।

बेहतर प्रदर्शन के बावजूद, इस विधि के अंदर एक ही चरण चल रहा है की तुलना में साथ तालमेल कर रहे हैं 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.0081, accuracy: 99.73%

अगले कदम