Quantize

सार्वजनिक अंतिम वर्ग क्वांटाइज़

फ़्लोट प्रकार के 'इनपुट' टेंसर को '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
यहां `रेंज(T) = न्यूमेरिक_लिमिट्स ::अधिकतम() - संख्यात्मक_सीमाएँ ::मिनट()`

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<T>::min()
 quantized = max(quantized, numeric_limits<T>::min())
 quantized = min(quantized, numeric_limits<T>::max())
इसके और MIN_COMBINED के बीच सबसे बड़ा अंतर यह है कि न्यूनतम सीमा को पहले गोल किया जाता है, इससे पहले कि इसे गोल मान से घटा दिया जाए। MIN_COMBINED के साथ, एक छोटा पूर्वाग्रह पेश किया जाता है जहां मात्रा निर्धारित करने और घटाने की बार-बार पुनरावृत्ति एक बड़ी और बड़ी त्रुटि पेश करेगी।

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

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

यदि मोड `स्केलेड` है, तो प्रत्येक इनपुट मान को स्केलिंग_फैक्टर से गुणा करके परिमाणीकरण किया जाता है। स्केलिंग_फैक्टर को `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);
हम इसके बाद 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 रेंज तक सीमित रहेगा। यह कुछ अनुमान बैकएंड के साथ अनुकूलता के लिए प्रदान किया गया है। (केवल स्केल्ड मोड पर लागू होता है)

अक्ष (पूर्णांक) विशेषता

एक वैकल्पिक `अक्ष` विशेषता इनपुट टेंसर के एक आयाम सूचकांक को निर्दिष्ट कर सकती है, जैसे कि परिमाणीकरण श्रेणियों की गणना की जाएगी और उस आयाम के साथ टेंसर के प्रत्येक स्लाइस के लिए अलग से लागू किया जाएगा। यह प्रति-चैनल परिमाणीकरण के लिए उपयोगी है।

यदि अक्ष निर्दिष्ट है, min_range और max_range

यदि `अक्ष`=कोई नहीं, प्रति-टेंसर परिमाणीकरण सामान्य रूप से किया जाता है।

सुनिश्चित_न्यूनतम_रेंज (फ्लोट) विशेषता

सुनिश्चित करता है कि न्यूनतम परिमाणीकरण सीमा कम से कम यह मान हो। इसके लिए लीगेसी डिफ़ॉल्ट मान 0.01 है, लेकिन नए उपयोगों के लिए इसे 0 पर सेट करने का दृढ़ता से सुझाव दिया गया है।

नेस्टेड क्लासेस

कक्षा परिमाणीकरण.विकल्प Quantize के लिए वैकल्पिक विशेषताएँ

स्थिरांक

डोरी OP_NAME इस ऑप का नाम, जैसा कि TensorFlow कोर इंजन द्वारा जाना जाता है

सार्वजनिक तरीके

स्थैतिक परिमाणीकरण.विकल्प
अक्ष (लंबा अक्ष)
स्थिर <T टीटाइप का विस्तार करता है > परिमाणीकरण <T> करता है
बनाएं ( स्कोप स्कोप, ऑपरेंड < TFloat32 > इनपुट, ऑपरेंड < TFloat32 > minRange, ऑपरेंड < TFloat32 > maxRange, क्लास<T> T, विकल्प... विकल्प)
एक नए क्वांटाइज़ ऑपरेशन को लपेटकर एक क्लास बनाने की फ़ैक्टरी विधि।
स्थैतिक परिमाणीकरण.विकल्प
सुनिश्चित करें न्यूनतम रेंज (फ्लोट सुनिश्चित करें न्यूनतम रेंज)
स्थैतिक परिमाणीकरण.विकल्प
मोड (स्ट्रिंग मोड)
स्थैतिक परिमाणीकरण.विकल्प
नैरोरेंज (बूलियन नैरोरेंज)
आउटपुट <T>
आउटपुट ()
फ्लोट इनपुट से उत्पादित मात्राबद्ध डेटा।
आउटपुट < TFloat32 >
आउटपुटमैक्स ()
अंतिम परिमाणीकरण सीमा अधिकतम, स्केलिंग से पहले इनपुट मानों को क्लिप करने और उन्हें परिमाणित मानों तक पूर्णांकित करने के लिए उपयोग की जाती है।
आउटपुट < TFloat32 >
आउटपुटमिन ()
अंतिम परिमाणीकरण सीमा न्यूनतम, स्केलिंग से पहले इनपुट मानों को क्लिप करने और उन्हें परिमाणित मानों तक पूर्णांकित करने के लिए उपयोग की जाती है।
स्थैतिक परिमाणीकरण.विकल्प
राउंडमोड (स्ट्रिंग राउंडमोड)

विरासत में मिली विधियाँ

स्थिरांक

सार्वजनिक स्थैतिक अंतिम स्ट्रिंग OP_NAME

इस ऑप का नाम, जैसा कि TensorFlow कोर इंजन द्वारा जाना जाता है

स्थिर मान: "QuantizeV2"

सार्वजनिक तरीके

सार्वजनिक स्थैतिक क्वांटाइज़.विकल्प अक्ष (लंबा अक्ष)

सार्वजनिक स्थैतिक क्वांटाइज़ <T> बनाएं ( स्कोप स्कोप, ऑपरेंड < TFloat32 > इनपुट, ऑपरेंड < TFloat32 > minRange, ऑपरेंड < TFloat32 > maxRange, क्लास<T> T, विकल्प... विकल्प)

एक नए क्वांटाइज़ ऑपरेशन को लपेटकर एक क्लास बनाने की फ़ैक्टरी विधि।

पैरामीटर
दायरा वर्तमान दायरा
न्यूनतम श्रेणी परिमाणीकरण सीमा का न्यूनतम मान. यह मान अन्य मापदंडों के आधार पर ऑप द्वारा समायोजित किया जा सकता है। समायोजित मान `आउटपुट_मिन` पर लिखा गया है। यदि `अक्ष` विशेषता निर्दिष्ट है, तो यह एक 1-डी टेंसर होना चाहिए जिसका आकार इनपुट और आउटपुट टेंसर के `अक्ष` आयाम से मेल खाता है।
अधिकतम सीमा परिमाणीकरण सीमा का अधिकतम मान. यह मान अन्य मापदंडों के आधार पर ऑप द्वारा समायोजित किया जा सकता है। समायोजित मान `आउटपुट_मैक्स` पर लिखा गया है। यदि `अक्ष` विशेषता निर्दिष्ट है, तो यह एक 1-डी टेंसर होना चाहिए जिसका आकार इनपुट और आउटपुट टेंसर के `अक्ष` आयाम से मेल खाता है।
विकल्प वैकल्पिक गुण मान रखता है
रिटर्न
  • क्वांटाइज़ का एक नया उदाहरण

सार्वजनिक स्थैतिक क्वांटाइज़.विकल्प न्यूनतम रेंज सुनिश्चित करते हैं (फ्लोट सुनिश्चित न्यूनतम रेंज)

सार्वजनिक स्थैतिक क्वांटाइज़.ऑप्शंस मोड (स्ट्रिंग मोड)

सार्वजनिक स्थैतिक क्वांटाइज़.विकल्प नैरोरेंज (बूलियन नैरोरेंज)

सार्वजनिक आउटपुट <T> आउटपुट ()

फ्लोट इनपुट से उत्पादित मात्राबद्ध डेटा।

सार्वजनिक आउटपुट < TFloat32 > आउटपुटमैक्स ()

अंतिम परिमाणीकरण सीमा अधिकतम, स्केलिंग से पहले इनपुट मानों को क्लिप करने और उन्हें परिमाणित मानों तक पूर्णांकित करने के लिए उपयोग की जाती है। यदि `अक्ष` विशेषता निर्दिष्ट है, तो यह एक 1-डी टेंसर होगा जिसका आकार इनपुट और आउटपुट टेंसर के `अक्ष` आयाम से मेल खाता है।

सार्वजनिक आउटपुट < TFloat32 > आउटपुटमिन ()

अंतिम परिमाणीकरण सीमा न्यूनतम, स्केलिंग से पहले इनपुट मानों को क्लिप करने और उन्हें परिमाणित मानों तक पूर्णांकित करने के लिए उपयोग की जाती है। यदि `अक्ष` विशेषता निर्दिष्ट है, तो यह एक 1-डी टेंसर होगा जिसका आकार इनपुट और आउटपुट टेंसर के `अक्ष` आयाम से मेल खाता है।

सार्वजनिक स्थैतिक क्वांटाइज़.ऑप्शंस राउंडमोड (स्ट्रिंग राउंडमोड)