इस पेज का अनुवाद 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 के साथ उपलब्ध हैं:

  • लगातार फोल्डिंग ऑप्टिमाइज़र - स्टेटिक रूप से ग्राफ़ में निरंतर नोड्स को फोल्ड करके जब संभव हो तो टेंसर्स के मूल्य को कम कर देता है और परिणाम को स्थिरांक के रूप में बदल देता है।
  • अंकगणितीय ऑप्टिमाइज़र - सामान्य सबटेक्शन्स को समाप्त करके अंकगणितीय संचालन को सरल बनाता है और अंकगणितीय कथनों को सरल बनाता है।
  • लेआउट ऑप्टिमाइज़र - डेटा स्वरूप निर्भर संचालन जैसे कि कॉन्फोल्यूशन को और अधिक कुशलता से निष्पादित करने के लिए टेंसर लेआउट का अनुकूलन करता है।
  • रेमापर ऑप्टिमाइज़र - अनुकूलित फ्यूज़ेड मोनोलिथिक कर्नेल के साथ आमतौर पर सबग्राफ को बदलने के द्वारा अधिक कुशल कार्यान्वयन पर सबग्राफ को रिमैप करता है।
  • मेमोरी ऑप्टिमाइज़र - प्रत्येक ऑपरेशन के लिए पीक मेमोरी उपयोग का निरीक्षण करने के लिए ग्राफ का विश्लेषण करता है और पीक मेमोरी के उपयोग को कम करने के लिए सीपीयू जीपीयू को स्वैप करने के लिए सीपीयू-जीपीयू मेमोरी कॉपी ऑपरेशन सम्मिलित करता है।
  • निर्भरता अनुकूलक - एक मॉडल कदम के लिए महत्वपूर्ण पथ को छोटा करने के लिए नियंत्रण निर्भरता को हटा या पुन: व्यवस्थित करता है या अन्य अनुकूलन को सक्षम करता है। ऐसे नोड्स को भी हटाता है जो प्रभावी रूप से नो-ऑप्स हैं जैसे कि आइडेंटिटी।
  • 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.0801323579999007 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.0006300529998952697 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 780, 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) ]]
  (1) Invalid argument:  Bad! : Tensor had Inf values
     [[node CheckNumerics (defined at <ipython-input-7-cbee1561c83e>:5) ]]
     [[Identity/_4]]
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 तर्क के कारण tf.debugging.check_numerics अमान्य तर्क त्रुटि 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 ग्राफ़ ऑप्टिमाइज़ेशन देखें।