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

#include <array_ops.h>

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

सारांश

[min_range और max_range] स्केलर फ्लोट हैं जो 'इनपुट' डेटा के लिए रेंज निर्दिष्ट करते हैं। 'mode' विशेषता यह नियंत्रित करती है कि फ्लोट मानों को उनके क्वांटाइज्ड समकक्षों में परिवर्तित करने के लिए किन गणनाओं का उपयोग किया जाता है। '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

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

MIN_COMBINED मोड का उदाहरण

मान लीजिए कि इनपुट का प्रकार फ्लोट है और इसकी संभावित सीमा [0.0, 6.0] है, जबकि आउटपुट का प्रकार quint8 ([0, 255]) है। min_range और max_range के मान क्रमशः 0.0 और 6.0 निर्दिष्ट किए जाने चाहिए। फ्लोट से 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::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 तक की सीमा T प्रकार के मानों के भीतर प्रदर्शित हो सके। 

  

  

    
  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 = 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) की सीमा में इनपुट मानों को परिमाणित करेंगे।
 इनपुट टेंसर को अब min_range से max_range सीमा तक मानों को क्लिप करके, फिर scale_factor से गुणा करके निम्नानुसार परिमाणित किया जा सकता है: 
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 = None है, तो प्रति-टेंसर क्वांटाइजेशन सामान्य रूप से किया जाता है।
 ensure_minimum_range (float) विशेषता
 यह सुनिश्चित करता है कि न्यूनतम क्वांटाइजेशन रेंज कम से कम इस मान के बराबर हो। इसका पुराना डिफ़ॉल्ट मान 0.01 है, लेकिन नए उपयोगों के लिए इसे 0 पर सेट करने की पुरजोर सलाह दी जाती है।
 तर्क:
  •  स्कोप: एक स्कोप ऑब्जेक्ट
  •  min_range: क्वांटाइजेशन रेंज का न्यूनतम मान। अन्य मापदंडों के आधार पर इस मान को समायोजित किया जा सकता है। समायोजित मान output_min में लिखा जाता है। यदि axis विशेषता निर्दिष्ट है, तो यह एक 1-D टेंसर होना चाहिए जिसका आकार इनपुट और आउटपुट टेंसर के axis आयाम से मेल खाता हो।
  •  max_range: क्वांटाइजेशन रेंज का अधिकतम मान। अन्य मापदंडों के आधार पर इस मान को समायोजित किया जा सकता है। समायोजित मान output_max में लिखा जाता है। यदि axis विशेषता निर्दिष्ट है, तो यह एक 1-D टेंसर होना चाहिए जिसका आकार इनपुट और आउटपुट टेंसर के axis आयाम से मेल खाता हो।
 प्रतिफल:
  •  Output : फ्लोट इनपुट से उत्पन्न परिमाणित डेटा।
  •  Output output_min: अंतिम क्वांटाइजेशन रेंज न्यूनतम, जिसका उपयोग इनपुट मानों को स्केल करने और क्वांटाइज्ड मानों में राउंड करने से पहले क्लिप करने के लिए किया जाता है। यदि axis विशेषता निर्दिष्ट है, तो यह एक 1-D टेंसर होगा जिसका आकार इनपुट और आउटपुट टेंसर के axis आयाम से मेल खाता है।
  •  Output output_max: अंतिम क्वांटाइजेशन रेंज की अधिकतम सीमा, जिसका उपयोग इनपुट मानों को स्केल करने और क्वांटाइज्ड मानों में राउंड करने से पहले क्लिप करने के लिए किया जाता है। यदि axis एट्रिब्यूट निर्दिष्ट है, तो यह एक 1-D टेंसर होगा जिसका आकार इनपुट और आउटपुट टेंसर के 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)
 संरचनाएँ
 टेन्सरफ्लो::ऑप्स::क्वांटाइज़वी2::एट्रिब्यूट्स
 QuantizeV2 के लिए वैकल्पिक विशेषता निर्धारक।
 सार्वजनिक विशेषताएँ 
 संचालन 
Operation operation
 आउटपुट 
::tensorflow::Output output
 आउटपुट_अधिकतम 
::tensorflow::Output output_max
 आउटपुट_मिन 
::tensorflow::Output output_min
सार्वजनिक समारोह 
 क्वांटाइज़वी2 
 QuantizeV2(
  const ::tensorflow::Scope & scope,
  ::tensorflow::Input input,
  ::tensorflow::Input min_range,
  ::tensorflow::Input max_range,
  DataType T
)
 क्वांटाइज़वी2 
 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
)