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

#include <array_ops.h>

फ़्लोट प्रकार के 'इनपुट' टेंसर को '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 है, तो प्रत्येक इनपुट मान को स्केलिंग_फैक्टर से गुणा करके परिमाणीकरण किया जाता है। स्केलिंग_फैक्टर को min_range और max_range से जितना संभव हो उतना बड़ा निर्धारित किया जाता है ताकि min_range से max_range तक की सीमा प्रकार टी के मानों के भीतर प्रतिनिधित्व योग्य हो।

  

  

    
  const int min_T = std::numeric_limits::min();
  const int max_T = std::numeric_limits::max();
  const float max_float = std::numeric_limits::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);

 हम min_range और max_range को निम्नानुसार समायोजित करने के लिए स्केल_फैक्टर का उपयोग करते हैं:
 
      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 से करेंगे, और स्केलिंग_फैक्टर = 12.8 सेट करेंगे, इस मामले में, min_range -10 रहेगा, लेकिन max_range को 127 / 12.8 = 9.921875 पर समायोजित किया जाएगा
 इसलिए हम इनपुट मानों को (-10, 9.921875) से (-128, 127) की सीमा में परिमाणित करेंगे।
 इनपुट टेंसर को अब min_range से max_range श्रेणी में मानों को क्लिप करके परिमाणित किया जा सकता है, फिर स्केल_फैक्टर द्वारा निम्नानुसार गुणा किया जा सकता है:
 
result = round(min(max_range, max(min_range, input)) * scale_factor)

 समायोजित min_range और max_range इस ऑपरेशन के आउटपुट 2 और 3 के रूप में लौटाए जाते हैं। इन आउटपुट का उपयोग किसी भी आगे की गणना के लिए सीमा के रूप में किया जाना चाहिए।
 नैरो_रेंज (बूल) विशेषता
 यदि सत्य है, तो हम न्यूनतम परिमाणित मान का उपयोग नहीं करते हैं। यानी int8 के लिए परिमाणित आउटपुट, यह पूर्ण -128..127 रेंज के बजाय -127..127 रेंज तक सीमित रहेगा। यह कुछ अनुमान बैकएंड के साथ अनुकूलता के लिए प्रदान किया गया है। (केवल स्केल्ड मोड पर लागू होता है)
 अक्ष (पूर्णांक) विशेषता
 एक वैकल्पिक axis विशेषता इनपुट टेंसर के एक आयाम सूचकांक को निर्दिष्ट कर सकती है, जैसे कि परिमाणीकरण श्रेणियों की गणना की जाएगी और उस आयाम के साथ टेंसर के प्रत्येक स्लाइस के लिए अलग से लागू किया जाएगा। यह प्रति-चैनल परिमाणीकरण के लिए उपयोगी है।
 यदि अक्ष निर्दिष्ट है, min_range और max_range
 यदि axis =कोई नहीं, प्रति-टेंसर परिमाणीकरण सामान्य रूप से किया जाता है।
 सुनिश्चित_न्यूनतम_रेंज (फ्लोट) विशेषता
 सुनिश्चित करता है कि न्यूनतम परिमाणीकरण सीमा कम से कम यह मान हो। इसके लिए लीगेसी डिफ़ॉल्ट मान 0.01 है, लेकिन नए उपयोगों के लिए इसे 0 पर सेट करने का दृढ़ता से सुझाव दिया गया है।
 तर्क:
  •  स्कोप: एक स्कोप ऑब्जेक्ट
  •  min_range: परिमाणीकरण सीमा का न्यूनतम मान। यह मान अन्य मापदंडों के आधार पर ऑप द्वारा समायोजित किया जा सकता है। समायोजित मान output_min पर लिखा गया है। यदि axis विशेषता निर्दिष्ट है, तो यह एक 1-डी टेंसर होना चाहिए जिसका आकार इनपुट और आउटपुट टेंसर के axis आयाम से मेल खाता है।
  •  max_range: परिमाणीकरण सीमा का अधिकतम मान। यह मान अन्य मापदंडों के आधार पर ऑप द्वारा समायोजित किया जा सकता है। समायोजित मान output_max पर लिखा गया है। यदि axis विशेषता निर्दिष्ट है, तो यह एक 1-डी टेंसर होना चाहिए जिसका आकार इनपुट और आउटपुट टेंसर के axis आयाम से मेल खाता है।
 रिटर्न:
  •  Output आउटपुट: फ्लोट इनपुट से उत्पादित मात्राबद्ध डेटा।
  •  Output आउटपुट_मिन: अंतिम परिमाणीकरण सीमा न्यूनतम, स्केलिंग से पहले इनपुट मानों को क्लिप करने और उन्हें परिमाणित मानों तक गोल करने के लिए उपयोग की जाती है। यदि axis विशेषता निर्दिष्ट है, तो यह एक 1-डी टेंसर होगा जिसका आकार इनपुट और आउटपुट टेंसर के axis आयाम से मेल खाता है।
  •  Output आउटपुट_मैक्स: अंतिम परिमाणीकरण सीमा अधिकतम, स्केलिंग से पहले इनपुट मानों को क्लिप करने और उन्हें परिमाणित मानों तक गोल करने के लिए उपयोग किया जाता है। यदि axis विशेषता निर्दिष्ट है, तो यह एक 1-डी टेंसर होगा जिसका आकार इनपुट और आउटपुट टेंसर के axis आयाम से मेल खाता है। 
 निर्माता और विध्वंसक
 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)
 
 सार्वजनिक गुण
 operation
 output
 output_max
 output_min 
सार्वजनिक स्थैतिक कार्य
 Axis (int64 x)
 EnsureMinimumRange (float x)
 Mode (StringPiece x)
 NarrowRange (bool x)
 RoundMode (StringPiece x) 
 संरचनाएँ
 टेंसरफ़्लो:: ऑप्स:: क्वांटाइज़V2:: एटर्स
 क्वांटाइज़V2 के लिए वैकल्पिक विशेषता सेटर्स।
 सार्वजनिक गुण 
 संचालन
 
Operation operation
 
 आउटपुट
 
::tensorflow::Output output
 
 आउटपुट_मैक्स
 
::tensorflow::Output output_max
 
 आउटपुट_मिन
 
::tensorflow::Output output_min
 सार्वजनिक समारोह 
 क्वांटाइज़V2
 
 QuantizeV2(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input input,
  ::tensorflow::Input min_range,
  ::tensorflow::Input max_range,
  DataType T
)
 
 क्वांटाइज़V2
 
 QuantizeV2(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input input,
  ::tensorflow::Input min_range,
  ::tensorflow::Input max_range,
  DataType T,
  const QuantizeV2::Attrs & attrs
)
 सार्वजनिक स्थैतिक कार्य 
 एक्सिस
 
Attrs Axis(
  int64 x
)
 
 न्यूनतम सीमा सुनिश्चित करें
 
Attrs EnsureMinimumRange(
  float x
)
 
 तरीका
 
Attrs Mode(
  StringPiece x
)
 
 संकीर्ण रेंज
 
Attrs NarrowRange(
  bool x
)
 
 राउंडमोड
 
Attrs RoundMode(
  StringPiece x
)