टेंसरफ़्लो:: ऑप्स:: क्वांटाइज़V2

फ़्लोट प्रकार के 'इनपुट' टेंसर को 'T' प्रकार के 'आउटपुट' टेंसर में परिमाणित करें।

सारांश

[min_range, max_range] स्केलर फ़्लोट हैं जो 'इनपुट' डेटा के लिए सीमा निर्दिष्ट करते हैं। 'मोड' विशेषता ठीक से नियंत्रित करती है कि फ्लोट मानों को उनके परिमाणित समकक्षों में परिवर्तित करने के लिए कौन सी गणनाओं का उपयोग किया जाता है। 'राउंड_मोड' विशेषता नियंत्रित करती है कि फ्लोट मानों को उनके परिमाणित समकक्षों में पूर्णांकित करते समय किस राउंडिंग टाई-ब्रेकिंग एल्गोरिदम का उपयोग किया जाता है।

'MIN_COMBINED' मोड में, टेंसर का प्रत्येक मान निम्नलिखित से गुजरेगा:

out[i] = (in[i] - min_range) * range(T) / (max_range - min_range)
if T == qint8: out[i] -= (range(T) + 1) / 2.0

यहां range(T) = numeric_limits ::max() - numeric_limits ::min() range(T) = numeric_limits ::max() - numeric_limits ::min() range(T) = numeric_limits ::max() - numeric_limits ::min()

MIN_COMBINED मोड उदाहरण

मान लें कि इनपुट प्रकार फ्लोट है और इसकी संभावित सीमा [0.0, 6.0] है और आउटपुट प्रकार क्विंट8 ([0, 255]) है। न्यूनतम_रेंज और अधिकतम_रेंज मान 0.0 और 6.0 के रूप में निर्दिष्ट किए जाने चाहिए। फ़्लोट से क्विंट8 तक मात्रा निर्धारित करने से इनपुट के प्रत्येक मान को 255/6 से गुणा किया जाएगा और क्विंट8 पर डाला जाएगा।

यदि आउटपुट प्रकार 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::min()
quantized = max(quantized, numeric_limits::min())
quantized = min(quantized, numeric_limits::max())

इसके और MIN_COMBINED के बीच सबसे बड़ा अंतर यह है कि न्यूनतम सीमा को पहले पूर्णांकित किया जाता है, इससे पहले कि इसे पूर्णांकित मान से घटाया जाए। MIN_COMBINED के साथ, एक छोटा पूर्वाग्रह पेश किया जाता है जहां मात्रा निर्धारित करने और घटाने की बार-बार पुनरावृत्ति एक बड़ी और बड़ी त्रुटि पेश करेगी।

स्केल्ड मोड उदाहरण

SCALED मोड QuantizeAndDequantize{V2|V3} में प्रयुक्त परिमाणीकरण दृष्टिकोण से मेल खाता है।

यदि मोड SCALED है, तो हम आउटपुट प्रकार की पूरी रेंज का उपयोग नहीं करते हैं, समरूपता के लिए न्यूनतम संभव मान को बढ़ाना चुनते हैं (उदाहरण के लिए, आउटपुट रेंज -127 से 127 है, हस्ताक्षरित 8 बिट परिमाणीकरण के लिए -128 से 127 नहीं), ताकि 0.0 0 पर मैप हो जाए।

हम सबसे पहले अपने टेंसर में मानों की श्रेणी ढूंढते हैं। हमारे द्वारा उपयोग की जाने वाली सीमा हमेशा 0 पर केंद्रित होती है, इसलिए हम m को ऐसे पाते हैं

  m = max(abs(input_min), abs(input_max))

हमारी इनपुट टेंसर रेंज तब [-m, m] है।

इसके बाद, हम अपनी निश्चित-बिंदु परिमाणीकरण बकेट, [min_fixed, max_fixed] चुनते हैं। यदि टी पर हस्ताक्षर किया गया है, तो यह है

  num_bits = sizeof(T) * 8
  [min_fixed, max_fixed] =
      [-(1 << (num_bits - 1) - 1), (1 << (num_bits - 1)) - 1]

अन्यथा, यदि टी अहस्ताक्षरित है, तो निश्चित-बिंदु सीमा है

  [min_fixed, max_fixed] = [0, (1 << num_bits) - 1]

इससे हम अपने स्केलिंग फैक्टर की गणना करते हैं:

  s = (max_fixed - min_fixed) / (2 * m)

अब हम अपने टेंसर के तत्वों की मात्रा निर्धारित कर सकते हैं:

result = round(input * s)

ध्यान रखने वाली एक बात यह है कि ऑपरेटर परिमाणीकरण प्रक्रिया के दौरान अनुरोधित न्यूनतम और अधिकतम मूल्यों को थोड़ा समायोजित करना चुन सकता है, इसलिए आपको आगे की गणना के लिए हमेशा आउटपुट पोर्ट को रेंज के रूप में उपयोग करना चाहिए। उदाहरण के लिए, यदि अनुरोधित न्यूनतम और अधिकतम मान बराबर के करीब हैं, तो गलत मात्रा वाले बफ़र्स को बनने से रोकने के लिए उन्हें एक छोटे ईपीएसलॉन मान से अलग किया जाएगा। अन्यथा, आप बफ़र्स के साथ समाप्त हो सकते हैं जहां सभी परिमाणित मान समान फ़्लोट मान पर मैप होते हैं, जो उन ऑपरेशनों के लिए समस्याएं पैदा करता है जिनके लिए उन पर आगे की गणना करनी होती है।

तर्क:

• स्कोप: एक स्कोप ऑब्जेक्ट
• min_range: इनपुट के लिए संभवतः उत्पन्न न्यूनतम स्केलर मान।
• max_range: इनपुट के लिए संभवतः उत्पादित अधिकतम स्केलर मान।

रिटर्न:

• Output आउटपुट: फ्लोट इनपुट से उत्पादित मात्राबद्ध डेटा।
• Output आउटपुट_मिन: आउटपुट के लिए उपयोग किया जाने वाला वास्तविक न्यूनतम स्केलर मान।
• Output आउटपुट_मैक्स: आउटपुट के लिए उपयोग किया जाने वाला वास्तविक अधिकतम स्केलर मान।

सार्वजनिक गुण

Operation operation

::tensorflow::Output output

::tensorflow::Output output_max

::tensorflow::Output output_min

 QuantizeV2(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input input,
  ::tensorflow::Input min_range,
  ::tensorflow::Input max_range,
  DataType T
)

 QuantizeV2(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input input,
  ::tensorflow::Input min_range,
  ::tensorflow::Input max_range,
  DataType T,
  const QuantizeV2::Attrs & attrs
)

Attrs Mode(
  StringPiece x
)

Attrs RoundMode(
  StringPiece x
)