इस पेज का अनुवाद Cloud Translation API से किया गया है.

टेन्सरफ्लो::ऑप्स::क्वांटाइज़वी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 है, तो हम आउटपुट प्रकार की पूरी रेंज का उपयोग नहीं करते हैं, समरूपता के लिए सबसे कम संभव मान को छोड़ देते हैं (उदाहरण के लिए, आउटपुट रेंज -127 से 127 है, न कि हस्ताक्षरित 8 बिट क्वांटिज़ेशन के लिए -128 से 127), ताकि 0.0 0 पर मैप हो जाए।

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

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

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

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

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

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

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

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

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

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

result = round(input * s)

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

तर्क:

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

प्रतिफल:

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

कंस्ट्रक्टर और डिस्ट्रक्टर
`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`	`Operation`
`output`	`:: tensorflow::Output`
`output_max`	`:: tensorflow::Output`
`output_min`	`:: tensorflow::Output`

सार्वजनिक स्थैतिक फ़ंक्शन
`Mode (StringPiece x)`	`Attrs`
`RoundMode (StringPiece x)`	`Attrs`

संरचनाएँ
टेन्सरफ्लो::ऑप्स::क्वांटाइज़वी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 Mode(
  StringPiece x
)

राउंडमोड

Attrs RoundMode(
  StringPiece x
)

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

सारांश

कंस्ट्रक्टर और डिस्ट्रक्टर

सार्वजनिक विशेषताएँ

सार्वजनिक स्थैतिक फ़ंक्शन

संरचनाएँ

सार्वजनिक विशेषताएँ

संचालन

आउटपुट

आउटपुट_अधिकतम

आउटपुट_मिन

सार्वजनिक समारोह

क्वांटाइज़वी2

क्वांटाइज़वी2

सार्वजनिक स्थैतिक फ़ंक्शन

तरीका

राउंडमोड