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

ग्रेप्लर के साथ TensorFlow ग्राफ अनुकूलन

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

अवलोकन

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

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

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

उपलब्ध ग्राफ़ ऑप्टिमाइज़र

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

  • लगातार फोल्डिंग ऑप्टिमाइज़र - स्टेटिक रूप से ग्राफ में निरंतर नोड्स को फोल्ड करके जब संभव हो तो टेंसरों के मूल्य को कम कर देता है और परिणाम को स्थिरांक बना देता है।
  • अंकगणितीय ऑप्टिमाइज़र - सामान्य सबटेक्शन्स को समाप्त करके अंकगणितीय संचालन को सरल करता है और अंकगणितीय कथनों को सरल बनाता है।
  • लेआउट ऑप्टिमाइज़र - डेटा स्वरूप निर्भर संचालन जैसे कि संकल्पों को और अधिक कुशलता से निष्पादित करने के लिए दसियों लेआउट का अनुकूलन करता है।
  • Remapper अनुकूलक - अनुकूलित फ्यूज़ेड मोनोलिथिक कर्नेल के साथ आमतौर पर सबग्राफ को बदलने के द्वारा अधिक कुशल कार्यान्वयन पर सबग्राफ को हटाता है।
  • मेमोरी ऑप्टिमाइज़र - प्रत्येक ऑपरेशन के लिए पीक मेमोरी उपयोग का निरीक्षण करने के लिए ग्राफ का विश्लेषण करता है और पीक मेमोरी के उपयोग को कम करने के लिए सीपीयू मेमोरी को सीपीयू को स्वैप करने के लिए सीपीयू-जीपीयू मेमोरी कॉपी ऑपरेशन सम्मिलित करता है।
  • निर्भरता अनुकूलक - एक मॉडल कदम के लिए महत्वपूर्ण पथ को छोटा करने के लिए नियंत्रण निर्भरता को हटा या पुन: व्यवस्थित करता है या अन्य अनुकूलन को सक्षम करता है। ऐसे नोड्स को भी हटाता है जो प्रभावी रूप से आइडेंटिटी जैसे नो-ऑप्स हैं।
  • Pruning optimizer - Prunes नोड्स जिनका ग्राफ से आउटपुट पर कोई प्रभाव नहीं है। यह आमतौर पर ग्राफ के आकार को कम करने और अन्य ग्रेपलर पास में प्रसंस्करण की गति को कम करने के लिए पहले चलाया जाता है।
  • फंक्शन ऑप्टिमाइज़र - अन्य इंटर-प्रक्रियात्मक अनुकूलन को सक्षम करने के लिए टेन्सरफ्लो प्रोग्राम के फ़ंक्शन लाइब्रेरी और इनलाइन फ़ंक्शन बॉडीज़ को ऑप्टिमाइज़ करता है।
  • आकार ऑप्टिमाइज़र - आकार और आकार से संबंधित जानकारी पर काम करने वाले सबग्राफ का अनुकूलन करता है।
  • ऑटोपारेलर ऑप्टिमाइज़र - स्वचालित रूप से बैच आयाम के साथ विभाजित करके ग्राफ़ को समानांतर करता है। यह ऑप्टिमाइज़र डिफ़ॉल्ट रूप से बंद है।
  • लूप ऑप्टिमाइज़र - लूप-इन्वारिएंट सबग्राफ को लूप से बाहर निकालकर और लूप्स में निरर्थक स्टैक ऑपरेशन को हटाकर ग्राफ कंट्रोल फ्लो को ऑप्टिमाइज़ करता है। इसके अलावा सांख्यिकीय रूप से ज्ञात ट्रिप काउंट के साथ छोरों का अनुकूलन करता है और सशर्त रूप से ज्ञात रूप से मृत शाखाओं को हटा देता है।
  • स्कॉप्ड एलोकेटर ऑप्टिमाइज़र - डेटा आंदोलन को कम करने और कुछ ऑपरेशनों को समेकित करने के लिए स्कॉप्ड एलोकेटर्स का परिचय देता है।
  • पिन को होस्ट करने वाला ऑप्टिमाइज़र - CPU पर छोटे ऑपरेशन को स्वैप करता है। यह ऑप्टिमाइज़र डिफ़ॉल्ट रूप से बंद है।
  • ऑटो मिश्रित सटीक ऑप्टिमाइज़र - प्रदर्शन को बेहतर बनाने के लिए डेटा प्रकार फ़्लोट 16 पर लागू करता है। वर्तमान में केवल GPU पर लागू होता है।
  • डीबग स्ट्रिपर - डिबगिंग ऑपरेशन से संबंधित tf.debugging.Assert नोड्स जैसे कि tf.debugging.Assert , tf.debugging.check_numerics , और tf.print से 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.004905937999865273 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.0005699149999145448 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)
 
Traceback (most recent call last):
  File "<ipython-input-8-1ac473fdfbab>", line 4, in <module>
    test_func(p1)
  File "/tmpfs/src/tf_docs_env/lib/python3.6/site-packages/tensorflow/python/eager/def_function.py", line 580, in __call__
    result = self._call(*args, **kwds)
tensorflow.python.framework.errors_impl.InvalidArgumentError: 2 root error(s) found.
  (0) Invalid argument:  Bad! : Tensor had Inf values
     [[node CheckNumerics (defined at <ipython-input-7-cbee1561c83e>:5) ]]
     [[Identity/_4]]
  (1) Invalid argument:  Bad! : Tensor had Inf values
     [[node CheckNumerics (defined at <ipython-input-7-cbee1561c83e>:5) ]]
0 successful operations.
0 derived errors ignored. [Op:__inference_simple_func_131]

Errors may have originated from an input operation.
Input Source operations connected to node CheckNumerics:
 input_arg (defined at <ipython-input-8-1ac473fdfbab>:4)

Input Source operations connected to node CheckNumerics:
 input_arg (defined at <ipython-input-8-1ac473fdfbab>:4)

Function call stack:
simple_func -> 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 से tf.debug.check_numerics नोड स्ट्रिप्स और बिना किसी त्रुटि के फ़ंक्शन को निष्पादित करता है।

सारांश

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

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