 TensorFlow.org এ দেখুন |  Google Colab-এ চালান |  GitHub-এ উৎস দেখুন |  নোটবুক ডাউনলোড করুন |
এই Colab নোটবুকটি চালানোর আগে, আপনার নোটবুকের সেটিংস চেক করে আপনার হার্ডওয়্যার অ্যাক্সিলারেটরটি একটি TPU কিনা তা নিশ্চিত করুন: রানটাইম > রানটাইম পরিবর্তন করুন > হার্ডওয়্যার অ্যাক্সিলারেটর > TPU ।
সেটআপ
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.8) or chardet (2.3.0)/charset_normalizer (2.0.11) doesn't match a supported version! RequestsDependencyWarning)
TPU সূচনা
TPU গুলি সাধারণত ক্লাউড TPU কর্মী, যা ব্যবহারকারীর পাইথন প্রোগ্রাম চালানো স্থানীয় প্রক্রিয়া থেকে আলাদা। এইভাবে, আপনাকে রিমোট ক্লাস্টারের সাথে সংযোগ করতে এবং TPU গুলি শুরু করতে কিছু প্রাথমিক কাজ করতে হবে। মনে রাখবেন tf.distribute.cluster_resolver.TPUClusterResolver-এর tpu আর্গুমেন্ট শুধুমাত্র tf.distribute.cluster_resolver.TPUClusterResolver এর জন্য একটি বিশেষ ঠিকানা। আপনি যদি 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.10:8470 INFO:tensorflow:Initializing the TPU system: grpc://10.240.1.10: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)
একটি গণনা প্রতিলিপি করতে যাতে এটি সমস্ত TPU কোরে চলতে পারে, আপনি এটি 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-তে শ্রেণীবিভাগ
মৌলিক ধারণাগুলি কভার করার পরে, একটি আরও সুনির্দিষ্ট উদাহরণ বিবেচনা করুন। ক্লাউড টিপিইউ-তে কেরাস মডেলকে প্রশিক্ষণ দেওয়ার জন্য কীভাবে বিতরণ tf.distribute.TPUStrategy কে ব্যবহার করতে হয় এই বিভাগটি প্রদর্শন করে।
একটি কেরাস মডেল সংজ্ঞায়িত করুন
কেরাস ব্যবহার করে MNIST ডেটাসেটে চিত্র শ্রেণীবিভাগের জন্য একটি Sequential কেরাস মডেলের সংজ্ঞা দিয়ে শুরু করুন। আপনি যদি CPUs বা GPU তে প্রশিক্ষণ নেন তবে আপনি যা ব্যবহার করবেন তার থেকে এটি আলাদা নয়। মনে রাখবেন যে কেরাস মডেল তৈরি করা দরকার 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 API-এর দক্ষ ব্যবহার গুরুত্বপূর্ণ, কারণ ক্লাউড টিপিইউ ব্যবহার করা অসম্ভব যদি না আপনি তাদের যথেষ্ট দ্রুত ডেটা দিতে পারেন। আপনি ইনপুট পাইপলাইন কর্মক্ষমতা নির্দেশিকা থেকে ডেটাসেট কর্মক্ষমতা সম্পর্কে আরও জানতে পারেন৷
সহজতম পরীক্ষা-নিরীক্ষার জন্য ( 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 এর অর্ডারে বড় ফাইলগুলি ব্যবহার করুন৷ এই নেটওয়ার্ক সেটিংয়ে এটি বিশেষভাবে গুরুত্বপূর্ণ, কারণ একটি ফাইল খোলার ওভারহেড উল্লেখযোগ্যভাবে বেশি।
নীচের কোডে দেখানো হয়েছে, MNIST প্রশিক্ষণ এবং পরীক্ষার ডেটার একটি অনুলিপি পেতে আপনার tensorflow_datasets মডিউলটি ব্যবহার করা উচিত। মনে রাখবেন যে 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 ব্যবহার করে মডেলকে প্রশিক্ষণ দিন
আপনি কেরাস fit এবং এপিআই compile করে আপনার মডেলকে প্রশিক্ষণ দিতে পারেন। এই ধাপে TPU-নির্দিষ্ট কিছু নেই—আপনি এমনভাবে কোড লিখছেন যেন আপনি TPUStrategy এর পরিবর্তে একাধিক GPU এবং একটি MirroredStrategy ব্যবহার করছেন। আপনি কেরাস টিউটোরিয়াল সহ বিতরণ করা প্রশিক্ষণে আরও শিখতে পারেন।
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.1433 - sparse_categorical_accuracy: 0.9564 - val_loss: 0.0452 - val_sparse_categorical_accuracy: 0.9859 Epoch 2/5 300/300 [==============================] - 6s 21ms/step - loss: 0.0335 - sparse_categorical_accuracy: 0.9898 - val_loss: 0.0318 - val_sparse_categorical_accuracy: 0.9899 Epoch 3/5 300/300 [==============================] - 6s 21ms/step - loss: 0.0199 - sparse_categorical_accuracy: 0.9935 - val_loss: 0.0397 - val_sparse_categorical_accuracy: 0.9866 Epoch 4/5 300/300 [==============================] - 6s 21ms/step - loss: 0.0109 - sparse_categorical_accuracy: 0.9964 - val_loss: 0.0436 - val_sparse_categorical_accuracy: 0.9892 Epoch 5/5 300/300 [==============================] - 6s 21ms/step - loss: 0.0103 - sparse_categorical_accuracy: 0.9963 - val_loss: 0.0481 - val_sparse_categorical_accuracy: 0.9881 <keras.callbacks.History at 0x7f0d485602e8>
Python ওভারহেড কমাতে এবং আপনার TPU-এর কর্মক্ষমতা বাড়াতে, আর্গুমেন্ট- 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 [==============================] - 12s 41ms/step - loss: 0.1515 - sparse_categorical_accuracy: 0.9537 - val_loss: 0.0416 - val_sparse_categorical_accuracy: 0.9863 Epoch 2/5 300/300 [==============================] - 3s 10ms/step - loss: 0.0366 - sparse_categorical_accuracy: 0.9891 - val_loss: 0.0410 - val_sparse_categorical_accuracy: 0.9875 Epoch 3/5 300/300 [==============================] - 3s 10ms/step - loss: 0.0191 - sparse_categorical_accuracy: 0.9938 - val_loss: 0.0432 - val_sparse_categorical_accuracy: 0.9865 Epoch 4/5 300/300 [==============================] - 3s 10ms/step - loss: 0.0141 - sparse_categorical_accuracy: 0.9951 - val_loss: 0.0447 - val_sparse_categorical_accuracy: 0.9875 Epoch 5/5 300/300 [==============================] - 3s 11ms/step - loss: 0.0093 - sparse_categorical_accuracy: 0.9968 - val_loss: 0.0426 - val_sparse_categorical_accuracy: 0.9884 <keras.callbacks.History at 0x7f0d0463cd68>
একটি কাস্টম প্রশিক্ষণ লুপ ব্যবহার করে মডেল প্রশিক্ষণ
এছাড়াও আপনি সরাসরি tf.function এবং tf.distribute API ব্যবহার করে আপনার মডেল তৈরি এবং প্রশিক্ষণ দিতে পারেন। একটি ডেটাসেট ফাংশন দেওয়া ডেটাসেট বিতরণ করতে আপনি strategy.experimental_distribute_datasets_from_function API ব্যবহার করতে পারেন। উল্লেখ্য যে নীচের উদাহরণে ডেটাসেটে পাস করা ব্যাচের আকার হল বিশ্বব্যাপী ব্যাচের আকারের পরিবর্তে প্রতি-প্রতিলিপি ব্যাচের আকার। আরও জানতে, 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.1339, accuracy: 95.79% Epoch: 1/5 Current step: 600, training loss: 0.0333, accuracy: 98.91% Epoch: 2/5 Current step: 900, training loss: 0.0176, accuracy: 99.43% Epoch: 3/5 Current step: 1200, training loss: 0.0126, accuracy: 99.61% Epoch: 4/5 Current step: 1500, training loss: 0.0122, accuracy: 99.61%
tf.function ভিতরে একাধিক ধাপ সহ কর্মক্ষমতা উন্নত করা
আপনি একটি tf.function মধ্যে একাধিক ধাপ চালিয়ে কর্মক্ষমতা উন্নত করতে পারেন। এটি tf.function এর ভিতরে একটি tf.range সহ strategy.run কলটি মোড়ানোর মাধ্যমে অর্জন করা হয় এবং অটোগ্রাফ এটিকে TPU কর্মীতে একটি tf.while_loop এ রূপান্তর করবে।
উন্নত কর্মক্ষমতা সত্ত্বেও, 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.74%
পরবর্তী পদক্ষেপ
- গুগল ক্লাউড টিপিইউ ডকুমেন্টেশন : কিভাবে একটি গুগল ক্লাউড টিপিইউ সেট আপ এবং চালাতে হয়।
- Google Cloud TPU Colab নোটবুক : এন্ড-টু-এন্ড প্রশিক্ষণের উদাহরণ।
- গুগল ক্লাউড টিপিইউ পারফরম্যান্স গাইড : আপনার অ্যাপ্লিকেশনের জন্য ক্লাউড টিপিইউ কনফিগারেশন প্যারামিটারগুলি সামঞ্জস্য করে ক্লাউড টিপিইউ কর্মক্ষমতা আরও উন্নত করুন
- TensorFlow-এর সাথে বিতরণ করা প্রশিক্ষণ : কীভাবে বিতরণ কৌশলগুলি ব্যবহার করতে
tf.distribute.TPUStrategyসহ—উদাহরণ সহ সর্বোত্তম অনুশীলন দেখানো হয়।