ग्रेप्लर के साथ टेंसरफ्लो ग्राफ अनुकूलन

TensorFlow.org पर देखें

Google Colab में चलाएं

GitHub पर स्रोत देखें

नोटबुक डाउनलोड करें

अवलोकन

TensorFlow गणनाओं को निष्पादित करने के लिए ग्राफ़ और उत्सुक निष्पादन दोनों का उपयोग करता है। एक tf.Graph में tf.Operation ऑब्जेक्ट्स (ops) का एक सेट होता है जो गणना की इकाइयों का प्रतिनिधित्व करता है और tf.Tensor ऑब्जेक्ट जो डेटा की इकाइयों का प्रतिनिधित्व करते हैं जो ops के बीच प्रवाहित होते हैं।

टेंसरफ्लो रनटाइम में ग्रेप्लर डिफ़ॉल्ट ग्राफ ऑप्टिमाइज़ेशन सिस्टम है। ग्रेप्लर ग्राफ मोड में अनुकूलन लागू करता है ( tf.function के भीतर) ग्राफ सरलीकरण और अन्य उच्च-स्तरीय अनुकूलन जैसे कि अंतर-प्रक्रियात्मक अनुकूलन को सक्षम करने के लिए इनलाइनिंग फ़ंक्शन निकायों के माध्यम से आपके TensorFlow संगणनाओं के प्रदर्शन को बेहतर बनाने के लिए। tf.Graph को ऑप्टिमाइज़ करने से डिवाइस की पीक मेमोरी का उपयोग भी कम हो जाता है और संसाधनों की गणना करने के लिए ग्राफ़ नोड्स के मैपिंग को ऑप्टिमाइज़ करके हार्डवेयर उपयोग में सुधार होता है।

अपने tf.Graph अनुकूलन पर बेहतर नियंत्रण के लिए tf.config.optimizer.set_experimental_options() का उपयोग करें।

उपलब्ध ग्राफ अनुकूलक

ग्रेप्लर MetaOptimizer नामक एक शीर्ष-स्तरीय ड्राइवर के माध्यम से ग्राफ़ अनुकूलन करता है। निम्नलिखित ग्राफ अनुकूलक TensorFlow के साथ उपलब्ध हैं:

कॉन्स्टेंट फोल्डिंग ऑप्टिमाइज़र - ग्राफ में स्थिर नोड्स को फोल्ड करके जब संभव हो तो टेंसर के मान को स्थिर रूप से अनुमानित करता है और स्थिरांक का उपयोग करके परिणाम को अमल में लाता है।
अंकगणित अनुकूलक - सामान्य उप-अभिव्यक्तियों को समाप्त करके और अंकगणितीय कथनों को सरल बनाकर अंकगणितीय संचालन को सरल बनाता है।
लेआउट ऑप्टिमाइज़र - डेटा प्रारूप पर निर्भर संचालन जैसे कि कनवल्शन को अधिक कुशलता से निष्पादित करने के लिए टेंसर लेआउट का अनुकूलन करता है।
रीमैपर ऑप्टिमाइज़र - आमतौर पर आने वाले सबग्राफ को अनुकूलित फ़्यूज़्ड मोनोलिथिक कर्नेल के साथ बदलकर अधिक कुशल कार्यान्वयन पर सबग्राफ को रीमैप करता है।
मेमोरी ऑप्टिमाइज़र - प्रत्येक ऑपरेशन के लिए पीक मेमोरी उपयोग का निरीक्षण करने के लिए ग्राफ का विश्लेषण करता है और पीक मेमोरी उपयोग को कम करने के लिए सीपीयू में जीपीयू मेमोरी को स्वैप करने के लिए सीपीयू-जीपीयू मेमोरी कॉपी ऑपरेशन सम्मिलित करता है।
निर्भरता अनुकूलक - मॉडल चरण के लिए महत्वपूर्ण पथ को छोटा करने या अन्य अनुकूलन को सक्षम करने के लिए नियंत्रण निर्भरताओं को हटा या पुनर्व्यवस्थित करता है। उन नोड्स को भी हटा देता है जो प्रभावी रूप से गैर-ऑप्स हैं जैसे कि पहचान।
प्रूनिंग ऑप्टिमाइज़र - उन नोड्स को काटता है जिनका ग्राफ़ से आउटपुट पर कोई प्रभाव नहीं पड़ता है। यह आमतौर पर ग्राफ के आकार को कम करने और अन्य ग्रेपलर पास में प्रसंस्करण को गति देने के लिए पहले चलाया जाता है।
फंक्शन ऑप्टिमाइज़र - एक TensorFlow प्रोग्राम के फंक्शन लाइब्रेरी को ऑप्टिमाइज़ करता है और अन्य इंटर-प्रक्रियात्मक ऑप्टिमाइज़ेशन को सक्षम करने के लिए फंक्शन बॉडीज़ को इनलाइन करता है।
शेप ऑप्टिमाइज़र - उन सबग्राफ को ऑप्टिमाइज़ करता है जो शेप और शेप से संबंधित जानकारी पर काम करते हैं।
ऑटोपैरेलल ऑप्टिमाइज़र - बैच आयाम के साथ विभाजित करके ग्राफ़ को स्वचालित रूप से समानांतर करता है। यह अनुकूलक डिफ़ॉल्ट रूप से बंद होता है।
लूप ऑप्टिमाइज़र - लूप-इनवेरिएंट सबग्राफ को लूप से बाहर निकालकर और लूप में अनावश्यक स्टैक ऑपरेशन को हटाकर ग्राफ़ नियंत्रण प्रवाह को अनुकूलित करता है। स्थैतिक रूप से ज्ञात यात्रा गणनाओं के साथ लूप को भी अनुकूलित करता है और सशर्त रूप से ज्ञात मृत शाखाओं को सशर्त रूप से हटा देता है।
स्कोप्ड एलोकेटर ऑप्टिमाइज़र - डेटा मूवमेंट को कम करने और कुछ ऑपरेशंस को समेकित करने के लिए स्कोप्ड एलोकेटर का परिचय देता है।
ऑप्टिमाइज़र को होस्ट करने के लिए पिन करें - सीपीयू पर छोटे ऑपरेशनों को स्वैप करें। यह अनुकूलक डिफ़ॉल्ट रूप से बंद होता है।
ऑटो मिक्स्ड प्रिसिजन ऑप्टिमाइज़र - डेटा प्रकारों को फ्लोट16 में कनवर्ट करता है जहां प्रदर्शन में सुधार के लिए लागू होता है। वर्तमान में केवल GPU पर लागू होता है।
डीबग स्ट्रिपर - ग्राफ़ से tf.debugging.Assert , tf.debugging.check_numerics , और tf.print जैसे डिबगिंग कार्यों से संबंधित स्ट्रिप्स नोड्स। यह अनुकूलक डिफ़ॉल्ट रूप से बंद होता है।

सेट अप

import numpy as np
import timeit
import traceback
import contextlib


import tensorflow as tf

अनुकूलक स्थितियों को आसानी से टॉगल करने के लिए एक संदर्भ प्रबंधक बनाएं।

@contextlib.contextmanager
def options(options):
  old_opts = tf.config.optimizer.get_experimental_options()
  tf.config.optimizer.set_experimental_options(options)
  try:
    yield
  finally:
    tf.config.optimizer.set_experimental_options(old_opts)

ग्रेप्लर के साथ और उसके बिना निष्पादन प्रदर्शन की तुलना करें

TensorFlow 2 और उसके बाद के संस्करण डिफ़ॉल्ट रूप से उत्सुकता से निष्पादित होते हैं। डिफ़ॉल्ट निष्पादन को ग्राफ़ मोड में बदलने के लिए tf.function का उपयोग करें। ऊपर दिए गए ग्राफ़ अनुकूलन को लागू करने और निष्पादन प्रदर्शन में सुधार करने के लिए ग्रेप्लर स्वचालित रूप से पृष्ठभूमि में चलता है।

लगातार तह अनुकूलक

प्रारंभिक उदाहरण के रूप में, एक फ़ंक्शन पर विचार करें जो स्थिरांक पर संचालन करता है और एक आउटपुट देता है।

def test_function_1():
  @tf.function
  def simple_function(input_arg):
    print('Tracing!')
    a = tf.constant(np.random.randn(2000,2000), dtype = tf.float32)
    c = a
    for n in range(50):
      c = c@a
    return tf.reduce_mean(c+input_arg)

  return simple_function

निरंतर तह अनुकूलक बंद करें और फ़ंक्शन निष्पादित करें:

with options({'constant_folding': False}):
  print(tf.config.optimizer.get_experimental_options())
  simple_function = test_function_1()
  # Trace once
  x = tf.constant(2.2)
  simple_function(x)
  print("Vanilla execution:", timeit.timeit(lambda: simple_function(x), number = 1), "s")

{'constant_folding': False, 'disable_model_pruning': False, 'disable_meta_optimizer': False}
Tracing!
Vanilla execution: 0.0018392090000816097 s

निरंतर फोल्डिंग ऑप्टिमाइज़र को सक्षम करें और फ़ंक्शन निष्पादन में गति-अप देखने के लिए फ़ंक्शन को फिर से निष्पादित करें।

with options({'constant_folding': True}):
  print(tf.config.optimizer.get_experimental_options())
  simple_function = test_function_1()
  # Trace once
  x = tf.constant(2.2)
  simple_function(x)
  print("Constant folded execution:", timeit.timeit(lambda: simple_function(x), number = 1), "s")

{'constant_folding': True, 'disable_model_pruning': False, 'disable_meta_optimizer': False}
Tracing!
Constant folded execution: 0.0006749789999958011 s

डीबग स्ट्रिपर अनुकूलक

एक साधारण फ़ंक्शन पर विचार करें जो इसके इनपुट तर्क के संख्यात्मक मान की जांच करता है और इसे वापस करता है।

def test_function_2():
  @tf.function
  def simple_func(input_arg):
    output = input_arg
    tf.debugging.check_numerics(output, "Bad!")
    return output
  return simple_func

सबसे पहले, डिबग स्ट्रिपर ऑप्टिमाइज़र बंद करके फ़ंक्शन को निष्पादित करें।

test_func = test_function_2()
p1 = tf.constant(float('inf'))
try:
  test_func(p1)
except tf.errors.InvalidArgumentError as e:
  traceback.print_exc(limit=2)

2021-09-22 20:34:55.871238: E tensorflow/core/kernels/check_numerics_op.cc:292] abnormal_detected_host @0x7f4878e00100 = {0, 1} Bad!
Traceback (most recent call last):
  File "/tmp/ipykernel_22954/3616845043.py", line 4, in <module>
    test_func(p1)
  File "/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/eager/def_function.py", line 885, in __call__
    result = self._call(*args, **kwds)
tensorflow.python.framework.errors_impl.InvalidArgumentError:  Bad! : Tensor had Inf values
     [[node CheckNumerics (defined at tmp/ipykernel_22954/2241890286.py:5) ]] [Op:__inference_simple_func_131]

Errors may have originated from an input operation.
Input Source operations connected to node CheckNumerics:
 input_arg (defined at tmp/ipykernel_22954/3616845043.py:4)

Function call stack:
simple_func

tf.debugging.check_numerics Inf तर्क test_func के कारण अमान्य तर्क त्रुटि उत्पन्न करता है।

डीबग स्ट्रिपर ऑप्टिमाइज़र सक्षम करें और फ़ंक्शन को फिर से निष्पादित करें।

with options({'debug_stripper': True}):
  test_func2 = test_function_2()
  p1 = tf.constant(float('inf'))
  try:
    test_func2(p1)
  except tf.errors.InvalidArgumentError as e:
    traceback.print_exc(limit=2)

डीबग स्ट्रिपर ऑप्टिमाइज़र ग्राफ़ से tf.debug.check_numerics नोड को हटा देता है और बिना किसी त्रुटि के फ़ंक्शन को निष्पादित करता है।

सारांश

TensorFlow रनटाइम निष्पादन से पहले ग्राफ़ को स्वचालित रूप से अनुकूलित करने के लिए ग्रेप्लर का उपयोग करता है। विभिन्न ग्राफ अनुकूलकों को सक्षम या अक्षम करने के लिए tf.config.optimizer.set_experimental_options का उपयोग करें।

ग्रेप्लर के बारे में अधिक जानकारी के लिए, टेंसरफ्लो ग्राफ ऑप्टिमाइजेशन देखें।