सहायता Kaggle पर TensorFlow साथ ग्रेट बैरियर रीफ की रक्षा चैलेंज में शामिल हों

टेंसरफ़्लो :: ऑप्स :: QuantizeV2

#include <array_ops.h>

टाइप 'फ्लो' टाइप के 'आउटपुट' को 'आउटपुट' के टेंसर को टाइप करें।

सारांश

[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]) है। Min_range और max_range मान 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 मोड उदाहरण

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

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

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

  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]

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

  [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_min: Output लिए उपयोग किया जाने वाला वास्तविक न्यूनतम स्केलर मान।
  • Output output_max: Output लिए प्रयुक्त वास्तविक अधिकतम स्केलर मान।

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

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

सार्वजनिक स्थैतिक कार्य

Mode (StringPiece x)
RoundMode (StringPiece x)

संरचनाएं

टेंसोफ़्लो :: ऑप्स :: क्वांटिज़ेव 2 :: एट्र्स

वैकल्पिक विशेषता QuantizeV2 के लिए बसती है

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

ऑपरेशन

Operation operation

उत्पादन

::tensorflow::Output output

output_max

::tensorflow::Output output_max

output_min

::tensorflow::Output output_min

सार्वजनिक कार्य

QuantizeV2

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

QuantizeV2

 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
)