इस पेज का अनुवाद Cloud Translation API से किया गया है.
Switch to English

TensorFlow Profiler: प्रोफ़ाइल मॉडल का प्रदर्शन

TensorFlow.org पर देखें Google Colab में चलाएं GitHub पर स्रोत देखें

अवलोकन

मशीन लर्निंग एल्गोरिदम आमतौर पर कम्प्यूटेशनल रूप से महंगे होते हैं। इस प्रकार यह सुनिश्चित करना महत्वपूर्ण है कि आप अपने मशीन लर्निंग एप्लीकेशन के प्रदर्शन को सुनिश्चित करें कि आप अपने मॉडल का सबसे अनुकूलित संस्करण चला रहे हैं। अपने TensorFlow कोड के निष्पादन को प्रोफाइल करने के लिए TensorFlow Profiler का उपयोग करें।

सेट अप

from datetime import datetime
from packaging import version

import os

TensorFlow Profiler को TensorFlow और TensorBoard ( >=2.2 ) के नवीनतम संस्करणों की आवश्यकता है।

pip install -U tensorboard_plugin_profile
WARNING: Skipping tensorflow as it is not installed.
WARNING: Skipping tensorboard as it is not installed.
[K     |████████████████████████████████| 517.1MB 31kB/s 
[K     |████████████████████████████████| 2.9MB 50.9MB/s 
[K     |████████████████████████████████| 1.1MB 61.2MB/s 
[K     |████████████████████████████████| 460kB 61.8MB/s 
[?25h
import tensorflow as tf

print("TensorFlow version: ", tf.__version__)
TensorFlow version:  2.2.0-dev20200405

पुष्टि करें कि TensorFlow GPU का उपयोग कर सकता है।

device_name = tf.test.gpu_device_name()
if not device_name:
  raise SystemError('GPU device not found')
print('Found GPU at: {}'.format(device_name))
Found GPU at: /device:GPU:0

TensorBoard कॉलबैक के साथ एक छवि वर्गीकरण मॉडल को प्रशिक्षित करें

इस ट्यूटोरियल में, आप MNIST डेटासेट में छवियों को वर्गीकृत करने के लिए एक मॉडल को प्रशिक्षित करके प्राप्त प्रदर्शन प्रोफ़ाइल को कैप्चर करके TensorFlow Profiler की क्षमताओं का पता लगाते हैं।

प्रशिक्षण डेटा आयात करने और इसे प्रशिक्षण और परीक्षण सेट में विभाजित करने के लिए TensorFlow डेटासेट का उपयोग करें।

import tensorflow_datasets as tfds
tfds.disable_progress_bar()
(ds_train, ds_test), ds_info = tfds.load(
    'mnist',
    split=['train', 'test'],
    shuffle_files=True,
    as_supervised=True,
    with_info=True,
)
WARNING:absl:Dataset mnist is hosted on GCS. It will automatically be downloaded to your
local data directory. If you'd instead prefer to read directly from our public
GCS bucket (recommended if you're running on GCP), you can instead set
data_dir=gs://tfds-data/datasets.


Downloading and preparing dataset mnist/3.0.0 (download: 11.06 MiB, generated: Unknown size, total: 11.06 MiB) to /root/tensorflow_datasets/mnist/3.0.0...
Dataset mnist downloaded and prepared to /root/tensorflow_datasets/mnist/3.0.0. Subsequent calls will reuse this data.

0 और 1 के बीच पिक्सेल मूल्यों को सामान्य करके प्रशिक्षण और परीक्षण डेटा को रोकें।

def normalize_img(image, label):
  """Normalizes images: `uint8` -> `float32`."""
  return tf.cast(image, tf.float32) / 255., label

ds_train = ds_train.map(normalize_img)
ds_train = ds_train.batch(128)
ds_test = ds_test.map(normalize_img)
ds_test = ds_test.batch(128)

कैरस का उपयोग करके छवि वर्गीकरण मॉडल बनाएं।

model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(input_shape=(28, 28, 1)),
  tf.keras.layers.Dense(128,activation='relu'),
  tf.keras.layers.Dense(10, activation='softmax')
])
model.compile(
    loss='sparse_categorical_crossentropy',
    optimizer=tf.keras.optimizers.Adam(0.001),
    metrics=['accuracy']
)

प्रदर्शन प्रोफ़ाइल कैप्चर करने के लिए एक TensorBoard कॉलबैक बनाएं और मॉडल को प्रशिक्षित करते समय इसे कॉल करें।

# Create a TensorBoard callback
logs = "logs/" + datetime.now().strftime("%Y%m%d-%H%M%S")

tboard_callback = tf.keras.callbacks.TensorBoard(log_dir = logs,
                                                 histogram_freq = 1,
                                                 profile_batch = '500,520')

model.fit(ds_train,
          epochs=2,
          validation_data=ds_test,
          callbacks = [tboard_callback])
Epoch 1/2
469/469 [==============================] - 11s 22ms/step - loss: 0.3684 - accuracy: 0.8981 - val_loss: 0.1971 - val_accuracy: 0.9436
Epoch 2/2
 50/469 [==>...........................] - ETA: 9s - loss: 0.2014 - accuracy: 0.9439WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/summary_ops_v2.py:1271: stop (from tensorflow.python.eager.profiler) is deprecated and will be removed after 2020-07-01.
Instructions for updating:
use `tf.profiler.experimental.stop` instead.

Warning:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/summary_ops_v2.py:1271: stop (from tensorflow.python.eager.profiler) is deprecated and will be removed after 2020-07-01.
Instructions for updating:
use `tf.profiler.experimental.stop` instead.

469/469 [==============================] - 11s 24ms/step - loss: 0.1685 - accuracy: 0.9525 - val_loss: 0.1376 - val_accuracy: 0.9595

<tensorflow.python.keras.callbacks.History at 0x7f23919a6a58>

मॉडल प्रशिक्षण प्रदर्शन को प्रोफ़ाइल करने के लिए TensorFlow Profiler का उपयोग करें

TensorFlow Profiler TensorBoard के भीतर एम्बेडेड है। Colab जादू का उपयोग करके TensorBoard लोड करें और इसे लॉन्च करें। प्रोफ़ाइल टैब पर नेविगेट करके प्रदर्शन प्रोफ़ाइल देखें।

# Load the TensorBoard notebook extension.
%load_ext tensorboard

इस मॉडल के लिए प्रदर्शन प्रोफ़ाइल नीचे दी गई छवि के समान है।

# Launch TensorBoard and navigate to the Profile tab to view performance profile
%tensorboard --logdir=logs
<IPython.core.display.Javascript object>

प्रोफ़ाइल टैब ओवरव्यू पृष्ठ खोलता है जो आपको अपने मॉडल प्रदर्शन का उच्च-स्तरीय सारांश दिखाता है। दाईं ओर स्टेप-टाइम ग्राफ़ को देखते हुए, आप देख सकते हैं कि मॉडल अत्यधिक इनपुट बाउंड है (यानी, डेटा इनपुट पाईपलाइन में बहुत समय खर्च होता है)। ओवरव्यू पृष्ठ आपको संभावित अगले चरणों की सिफारिशें भी देता है, जिन्हें आप अपने मॉडल के प्रदर्शन का अनुकूलन करने के लिए कर सकते हैं।

इनपुट पाइपलाइन में प्रदर्शन अड़चन कहां होती है, यह समझने के लिए, बाईं ओर स्थित टूल ड्रॉपडाउन से ट्रेस व्यूअर का चयन करें। ट्रेस व्यूअर आपको प्रोफाइलिंग अवधि के दौरान सीपीयू और जीपीयू पर होने वाली विभिन्न घटनाओं की समयरेखा दिखाता है।

ट्रेस व्यूअर ऊर्ध्वाधर अक्ष पर कई ईवेंट समूह दिखाता है। प्रत्येक ईवेंट समूह में कई क्षैतिज ट्रैक होते हैं, जो ट्रेस घटनाओं से भरे होते हैं। ट्रैक एक थ्रेड या GPU स्ट्रीम पर निष्पादित घटनाओं के लिए एक इवेंट टाइमलाइन है। अलग-अलग घटनाओं में समयरेखा पटरियों पर रंगीन, आयताकार ब्लॉक होते हैं। समय बाएं से दाएं चलता है। कीबोर्ड शॉर्टकट W (ज़ूम इन), S (ज़ूम आउट), A (स्क्रॉल बाएं), और D (स्क्रॉल राइट) का उपयोग करके ट्रेस ईवेंट्स को नेविगेट करें।

एक एकल आयत एक ट्रेस घटना का प्रतिनिधित्व करता है। फ्लोटिंग टूल बार में माउस कर्सर आइकन का चयन करें (या कीबोर्ड शॉर्टकट 1 उपयोग करें) और इसका विश्लेषण करने के लिए ट्रेस इवेंट पर क्लिक करें। यह घटना के बारे में जानकारी प्रदर्शित करेगा, जैसे कि इसका प्रारंभ समय और अवधि।

क्लिक करने के अलावा, आप ट्रेस घटनाओं के एक समूह का चयन करने के लिए माउस को खींच सकते हैं। यह आपको उस क्षेत्र की सभी घटनाओं की एक सूची सारांश के साथ देगा। चयनित घटनाओं की समय अवधि को मापने के लिए M कुंजी का उपयोग करें।

ट्रेस घटनाओं से एकत्र कर रहे हैं:

  • CPU: CPU ईवेंट्स को एक इवेंट ग्रुप के नाम से प्रदर्शित किया जाता है जिसका नाम /host:CPU । प्रत्येक ट्रैक सीपीयू पर एक थ्रेड का प्रतिनिधित्व करता है। CPU इवेंट्स में इनपुट पाइपलाइन इवेंट्स, GPU ऑपरेशन (op) शेड्यूलिंग इवेंट्स, CPU ऑप एक्जीक्यूटिव इवेंट्स आदि शामिल हैं।
  • जीपीयू: जीपीयू इवेंट्स /device:GPU: द्वारा उपसर्ग किए गए इवेंट समूहों के तहत प्रदर्शित किए जाते हैं। प्रत्येक ईवेंट समूह GPU पर एक स्ट्रीम का प्रतिनिधित्व करता है।

डिबग प्रदर्शन बाधाओं

अपने इनपुट पाइप लाइन में प्रदर्शन की अड़चनों का पता लगाने के लिए ट्रेस व्यूअर का उपयोग करें। नीचे दी गई छवि प्रदर्शन प्रोफ़ाइल का एक स्नैपशॉट है।

profiler_trace_viewer_bad_ip

ईवेंट के निशानों को देखते हुए, आप देख सकते हैं कि CPU निष्क्रिय है जबकि tf_data_iterator_get_next ऑप CPU पर चल रहा है। यह op इनपुट डेटा को संसाधित करने और प्रशिक्षण के लिए GPU पर भेजने के लिए ज़िम्मेदार है। अंगूठे के एक सामान्य नियम के रूप में, डिवाइस (GPU / TPU) को हमेशा सक्रिय रखना एक अच्छा विचार है।

इनपुट पाइपलाइन का अनुकूलन करने के लिए tf.data API का उपयोग करें। इस मामले में, आइए प्रशिक्षण डेटासेट को कैश करें और यह सुनिश्चित करने के लिए डेटा को प्रीफ़ेक करें कि GPU के लिए हमेशा डेटा उपलब्ध है। अपने इनपुट पाइपलाइनों को अनुकूलित करने के लिए tf.data का उपयोग करने के बारे में अधिक जानकारी के लिए यहां देखें।

(ds_train, ds_test), ds_info = tfds.load(
    'mnist',
    split=['train', 'test'],
    shuffle_files=True,
    as_supervised=True,
    with_info=True,
)
ds_train = ds_train.map(normalize_img)
ds_train = ds_train.batch(128)
ds_train = ds_train.cache()
ds_train = ds_train.prefetch(tf.data.experimental.AUTOTUNE)
ds_test = ds_test.map(normalize_img)
ds_test = ds_test.batch(128)
ds_test = ds_test.cache()
ds_test = ds_test.prefetch(tf.data.experimental.AUTOTUNE)

मॉडल को फिर से प्रशिक्षित करें और पहले से कॉलबैक का पुन: उपयोग करके प्रदर्शन प्रोफ़ाइल पर कब्जा करें।

आ 78923b3f
Epoch 1/2
469/469 [==============================] - 10s 22ms/step - loss: 0.1194 - accuracy: 0.9658 - val_loss: 0.1116 - val_accuracy: 0.9680
Epoch 2/2
469/469 [==============================] - 1s 3ms/step - loss: 0.0918 - accuracy: 0.9740 - val_loss: 0.0979 - val_accuracy: 0.9712

<tensorflow.python.keras.callbacks.History at 0x7f23908762b0>

अपडेट किए गए इनपुट पाइपलाइन के लिए प्रदर्शन प्रोफ़ाइल का निरीक्षण करने के लिए TensorBoard को फिर से लॉन्च करें और प्रोफ़ाइल टैब खोलें।

अनुकूलित इनपुट पाइपलाइन के साथ मॉडल के लिए प्रदर्शन प्रोफ़ाइल नीचे दी गई छवि के समान है।

%tensorboard --logdir=logs
Reusing TensorBoard on port 6006 (pid 750), started 0:00:12 ago. (Use '!kill 750' to kill it.)
<IPython.core.display.Javascript object>

अवलोकन पृष्ठ से, आप देख सकते हैं कि इनपुट चरण समय के अनुसार औसत चरण का समय कम हो गया है। स्टेप-टाइम ग्राफ यह भी बताता है कि मॉडल अब अत्यधिक इनपुट बाउंड नहीं है। अनुकूलित इनपुट पाइपलाइन के साथ ट्रेस घटनाओं की जांच करने के लिए ट्रेस व्यूअर खोलें।

profiler_trace_viewer_good_ip

ट्रेस दर्शक से पता चलता है कि tf_data_iterator_get_next op बहुत तेज़ी से निष्पादित होता है। इसलिए GPU प्रशिक्षण प्राप्त करने के लिए डेटा की एक स्थिर धारा प्राप्त करता है और मॉडल प्रशिक्षण के माध्यम से बेहतर उपयोग प्राप्त करता है।

सारांश

प्रोफ़ाइल और डिबग मॉडल प्रशिक्षण प्रदर्शन के लिए TensorFlow Profiler का उपयोग करें। प्रोफाइलर गाइड पढ़ें और TensorFlow Dev समिट 2020 से TensorFlow Profiler के बारे में अधिक जानने के लिए TF 2 में प्रदर्शन प्रोफाइल देखें