Quantize

שיעור הגמר הציבורי Quantize

כוונט את טנסור ה"קלט" מסוג float לטנסור "פלט" מסוג "T".

[min_range, max_range] הם צפים סקלאריים המציינים את הטווח עבור נתוני 'הקלט'. התכונה 'מצב' שולטת בדיוק באילו חישובים נעשה שימוש כדי להמיר את ערכי הציפה למקבילות הכמותיות שלהם. התכונה 'round_mode' שולטת באיזה אלגוריתם שובר שוויון עיגול נעשה שימוש בעת עיגול ערכי ציפה למקבילותיהם הכומתיים.

במצב 'MIN_COMBINED', כל ערך של הטנזור יעבור את הפעולות הבאות:

out[i] = (in[i] - min_range) * range(T) / (max_range - min_range)
 if T == qint8: out[i] -= (range(T) + 1) / 2.0
 
כאן `טווח (T) = מספר_גבולות ::max() - מספר_מגבלות ::min()`

דוגמה למצב MIN_COMBINED

נניח שהקלט הוא מסוג float ויש לו טווח אפשרי של [0.0, 6.0] וסוג הפלט הוא quint8 ([0, 255]). יש לציין את ערכי min_range ו-max_range כ-0.0 ו-6.0. כימות מ-float ל-quint8 יכפיל כל ערך של הקלט ב-255/6 ויטיל ל-quint8.

אם סוג הפלט היה qint8 ([-128, 127]), הפעולה תגרע בנוסף כל ערך ב-128 לפני הליהוק, כך שטווח הערכים יתיישר עם הטווח של qint8.

אם המצב הוא 'MIN_FIRST', הגישה הזו משמשת:

num_discrete_values = 1 << (# of bits in T)
 range_adjust = num_discrete_values / (num_discrete_values - 1)
 range = (range_max - range_min) * range_adjust
 range_scale = num_discrete_values / range
 quantized = round(input * range_scale) - round(range_min * range_scale) +
   numeric_limits<T>::min()
 quantized = max(quantized, numeric_limits<T>::min())
 quantized = min(quantized, numeric_limits<T>::max())
 
ההבדל הגדול ביותר בין זה לבין MIN_COMBINED הוא שהטווח המינימלי מעוגל תחילה, לפני שהוא מופחת מהערך המעוגל. עם MIN_COMBINED, הטיה קטנה מוצגת כאשר איטרציות חוזרות ונשנות של כימות וסילוק קוונטיות יציגו שגיאה גדולה יותר ויותר.

דוגמה למצב SCALED

מצב `SCALED` תואם את גישת הקוונטיזציה המשמשת ב-`QuantizeAndDequantize{V2|V3}`.

אם המצב הוא `SCALED`, הקוונטיזציה מתבצעת על ידי הכפלת כל ערך קלט ב-scaling_factor. ה-scaling_factor נקבע מ-min_range ו-max_range להיות גדול ככל האפשר כך שהטווח מ-min_range ל-max_range ניתן לייצוג בתוך ערכים מסוג T.

const int min_T = std::numeric_limits<T>::min();
   const int max_T = std::numeric_limits<T>::max();
   const float max_float = std::numeric_limits<float>::max();
 
   const float scale_factor_from_min_side =
       (min_T * min_range > 0) ? min_T / min_range : max_float;
   const float scale_factor_from_max_side =
       (max_T * max_range > 0) ? max_T / max_range : max_float;
 
   const float scale_factor = std::min(scale_factor_from_min_side,
                                       scale_factor_from_max_side);
 
לאחר מכן אנו משתמשים ב-scale_factor כדי לכוונן טווח_מינימלי וטווח_מקסימלי באופן הבא:
min_range = min_T / scale_factor;
       max_range = max_T / scale_factor;
 
למשל אם T = qint8, ובהתחלה min_range = -10, ו-max_range = 9, נשווה -128/-10.0 = 12.8 ל-127/9.0 = 14.11, ונקבע scaling_factor = 12.8 במקרה זה, min_range יישאר -10, אבל max_range יותאם ל-127 / 12.8 = 9.921875

אז נכמת ערכי קלט בטווח (-10, 9.921875) עד (-128, 127).

כעת ניתן לכמת את טנזור הקלט על ידי חיתוך ערכים לטווח 'טווח_מינימלי' עד 'טווח_מקסימלי', ולאחר מכן להכפיל ב-scale_factor באופן הבא:

result = round(min(max_range, max(min_range, input)) * scale_factor)
 
ה-min_range וה-max_range המותאמים מוחזרים כמוצאים 2 ו-3 של פעולה זו. יש להשתמש בתפוקות אלה כטווח עבור כל חישוב נוסף.

תכונת narrow_range (bool).

אם זה נכון, אנחנו לא משתמשים בערך המינימלי הקוונטי. כלומר עבור int8 הפלט המקוונטי, הוא יהיה מוגבל לטווח -127..127 במקום לטווח -128..127 המלא. זה מסופק עבור תאימות עם מסקנות עורפיות מסוימות. (חל רק על מצב SCALED)

תכונת ציר (int).

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

אם צוין ציר, min_range ו-max_range

אם `ציר`=אין, קוונטיזציה לפי טנזור מבוצעת כרגיל.

תכונת טווח_מינימום (צף).

מבטיח שטווח הקוונטיזציה המינימלי הוא לפחות ערך זה. ערך ברירת המחדל הישן עבור זה הוא 0.01, אך מומלץ מאוד להגדיר אותו ל-0 עבור שימושים חדשים.

כיתות מקוננות

מַחלָקָה quantize.Options תכונות אופציונליות עבור Quantize

קבועים

חוּט OP_NAME השם של המבצע הזה, כפי שידוע על ידי מנוע הליבה של TensorFlow

שיטות ציבוריות

סטטי Quantize.Options
ציר (ציר ארוך)
סטטי <T מרחיב TType > Quantize <T>
create ( scope scope, Operand < TFloat32 > input, Operand < TFloat32 > minRange, Operand < TFloat32 > maxRange, Class<T> T, Options... options)
שיטת מפעל ליצירת מחלקה העוטפת פעולת Quantize חדשה.
סטטי Quantize.Options
sureMinimumRange (צף להבטיחMinimumRange)
סטטי Quantize.Options
מצב (מצב מחרוזת)
סטטי Quantize.Options
narrowRange (בוליאני narrowRange)
פלט <T>
פלט ()
הנתונים הכומתיים שהופקו מהקלט הצף.
פלט < TFloat32 >
OutputMax ()
טווח הקוונטיזציה הסופי המקסימלי, המשמש לגזירת ערכי קלט לפני קנה המידה ועיגולם לערכים כמותיים.
פלט < TFloat32 >
outputMin ()
המינימום של טווח הקוונטיזציה הסופי, המשמש לגזירת ערכי קלט לפני שינוי קנה מידה ועיגולם לערכים כמותיים.
סטטי Quantize.Options
roundMode (מחרוזת roundMode)

שיטות בירושה

קבועים

מחרוזת סופית סטטית ציבורית OP_NAME

השם של המבצע הזה, כפי שידוע על ידי מנוע הליבה של TensorFlow

ערך קבוע: "QuantizeV2"

שיטות ציבוריות

ציר Quantize.Options סטטי ציבורי (ציר ארוך)

public static Quantize <T> create ( Scope scope, Operand < TFloat32 > input, Operand < TFloat32 > minRange, Operand < TFloat32 > maxRange, Class<T> T, Options... options)

שיטת מפעל ליצירת מחלקה העוטפת פעולת Quantize חדשה.

פרמטרים
תְחוּם ההיקף הנוכחי
minRange הערך המינימלי של טווח הקוונטיזציה. ערך זה עשוי להיות מותאם על ידי ה-op בהתאם לפרמטרים אחרים. הערך המותאם נכתב ב-'output_min'. אם מציינת תכונת ה'ציר', זה חייב להיות טנזור 1-D שגודלו תואם את ממד ה'ציר' של טנסור הקלט והפלט.
maxRange הערך המרבי של טווח הקוונטיזציה. ערך זה עשוי להיות מותאם על ידי ה-op בהתאם לפרמטרים אחרים. הערך המותאם נכתב ל-'output_max'. אם מציינת תכונת ה'ציר', זה חייב להיות טנזור 1-D שגודלו תואם את ממד ה'ציר' של טנסור הקלט והפלט.
אפשרויות נושא ערכי תכונות אופציונליות
מחזיר
  • מופע חדש של Quantize

public static Quantize.Options secureMinimumRange (צף להבטיחMinimumRange)

מצב Quantize.Options סטטי ציבורי (מצב מחרוזת)

Public static Quantize.Options narrowRange (בווליאני narrowRange)

פלט ציבורי <T> פלט ()

הנתונים הכומתיים שהופקו מהקלט הצף.

פלט ציבורי < TFloat32 > outputMax ()

טווח הקוונטיזציה הסופי המקסימלי, המשמש לגזירת ערכי קלט לפני קנה המידה ועיגולם לערכים כמותיים. אם תצוין תכונת ה'ציר', זה יהיה טנזור 1-D שגודלו תואם את ממד ה'ציר' של טנסור הקלט והפלט.

פלט ציבורי < TFloat32 > outputMin ()

המינימום של טווח הקוונטיזציה הסופי, המשמש לגזירת ערכי קלט לפני קנה המידה ועיגולם לערכים כמותיים. אם תצוין תכונת ה'ציר', זה יהיה טנזור 1-D שגודלו תואם את ממד ה'ציר' של טנסור הקלט והפלט.

Public static Quantize.Options roundMode (String roundMode)