דף זה תורגם על ידי Cloud Translation API.
Switch to English

אופטימיזציה גרף TensorFlow עם grappler

צפה על TensorFlow.org הפעל ב Google Colab מקור צפה על GitHub מחברת להורדה

סקירה כללית

TensorFlow משתמשת בשני הגרפים והוצאות להורג להוט לבצע חישובים. tf.Graph מכיל סט של tf.Operation חפצים (ops) אשר מייצגים יחידות של חישוב tf.Tensor חפצים אשר מייצגים את יחידות של נתונים שזורמים בין Ops.

Grappler היא מערכת אופטימיזציה גרף ברירת המחדל של ריצת TensorFlow. Grappler חל אופטימיזציות במצב גרף (בתוך tf.function ) כדי לשפר את הביצועים של חישובי TensorFlow שלך דרך פישוטי גרף אופטימיזציות ברמה גבוהה אחרות כגון inlining גופי פונקציה לאפשר אופטימיזציות בין-פרוצדורלית. אופטימיזציה של tf.Graph גם מקטין את השימוש בזיכרון שיא המכשיר משפר את ניצול חומרה על ידי אופטימיזציה של המיפוי של בלוטות גרף למשאבי מחשוב.

השתמש tf.config.optimizer.set_experimental_options() עבור שליטה מדויקת יותר על שלך tf.Graph אופטימיזציות.

אופטימיזציה גרף זמין

Grappler מבצע גרף אופטימיזציות באמצעות נהג ברמה העליונה שנקרא MetaOptimizer . אופטימיזציה הגרף שלהלן זמינה עם TensorFlow:

  • האופטימיזציה מתקפלים מתמיד - סטטי מסיק הערך של טנזורים במידת האפשר על ידי קיפול צמתים מתמדת בגרף ו תתממש התוצאה באמצעות קבועים.
  • האופטימיזציה אריתמטיקה - מפשט פעולות אריתמטיות על ידי ביטול subexpressions המשותף פישוט דוחות חשבון.
  • פריסת האופטימיזציה - מייעלת מותח פריסות לבצע פעולות תלוי בפורמט נתונים כגון פיתולים ביעילות רבה יותר.
  • האופטימיזציה remapper - remaps subgraphs על הטמעות יעילות יותר על ידי החלפת subgraphs התרחשות כלל עם גרעינים מונוליטי התמזגו מותאמים.
  • האופטימיזציה זיכרון - ניתוח גרף לבדוק את השימוש בזיכרון השיא עבור כל פעולות תפעול מוסיף CPU-GPU עותק זיכרון לעברת זיכרון GPU כדי CPU כדי להפחית את השימוש בזיכרון השיא.
  • האופטימיזציה תלות - מסירים או מארגן מחדש לשלוט תלות לקצר את הנתיב הקריטי עבור צעד מודל או מאפשרת אופטימיזציה אחרת. כמו כן מסיר בלוטות כי הם ביעילות ללא ops כגון זהות.
  • גיזום האופטימיזציה - בלוטות שזיפים שאין להם השפעה על התפוקה מן הגרף. הוא בדרך כלל להפעיל תחילה להקטין את גודל הגרף ולהאיץ עיבוד grappler האחר עובר.
  • ייעול תפקוד - מייעל את ספריית הפונקציה של תכנית inlines TensorFlow לתפקד גופים לאפשר אופטימיזציות בין-פרוצדורליים אחרות.
  • האופטימיזציה Shape - מייעל subgraphs שפועלים על הצורה ולעצב את המידע הרלוונטי.
  • האופטימיזציה Autoparallel - אוטומטית parallelizes גרפים ידי פיצול לאורך המימד אצווה. האופטימיזציה זו כבויה כברירת מחדל.
  • Loop האופטימיזציה - מייעל את זרימת שליטה גרף בהנפת subgraphs-שמורת הלולאה מתוך לולאות ידי הסרת פעולות ערימה מיותר לולאות. כמו כן מייעל לולאות עם ספירת טיול ידוע סטטי ומסיר סטטי ידוע סניפים מת התניות.
  • האופטימיזציה allocator היקף ברמת - מציגה scoped מקצי להפחית להעברת נתונים כדי לבסס פעולות מסוימות.
  • צמד האופטימיזציה מארח - פעולות קטנות Swaps גבי המעבד. האופטימיזציה זו כבויה כברירת מחדל.
  • אופטימיזציה אוטומטית דיוק מעורבת - סוגי נתונים המתגיירים כדי float16 ישים כדי לשפר את הביצועים. חל כרגע רק על GPUs.
  • חשפנית Debug - בלוטות רצועות הקשורות לפעילות באגים כגון 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)
 

ביצועי ביצוע השוו עם ובלי grappler

TensorFlow 2 ומעבר עוסקת בביצוע בשקיקה כברירת מחדל. השתמש tf.function לעבור לביצוע המחדל למצב גרף. Grappler פועל באופן אוטומטי ברקע כדי להחיל את אופטימיזציות הגרף שלעיל ולשפר ביצועים ביצוע.

האופטימיזציה מתקפל Constant

כדוגמה ראשונית, לשקול פונקציה אשר מבצעת פעולות על קבועי ומחזירה פלט.

 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

Debug חשפנית האופטימיזציה

קח פונקציה פשוט הבודק את הערך המספרי של טיעון הקלט שלה ומחזיר אותו.

 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 צומת מהגרף ומבצע את הפונקציה מבלי להעלות את כל שגיאות.

סיכום

זמן ריצת TensorFlow משתמשת grappler כדי גרפי אופטימיזציה אוטומטית לפני ביצוע. השתמש tf.config.optimizer.set_experimental_options כדי להפעיל או להשבית את כלי אופטימיזציה של הגרף השונה.

לקבלת מידע נוסף על grappler, לראות TensorFlow גרף אופטימיזציות .