ट्रेनिंग के बाद संख्या बढ़ाने की सुविधा

ट्रेनिंग के बाद संख्या बढ़ाना एक कन्वर्ज़न तकनीक है, जो मॉडल के साइज़ को कम कर सकती है इसके अलावा, यह सीपीयू और हार्डवेयर ऐक्सेलरेटर लेटेंसी में भी सुधार करता है. मॉडल सटीक होने में गिरावट आई है. आप पहले से ट्रेन किए गए फ़्लोट को माप सकते हैं TensorFlow मॉडल, जब उसे LiteRT कन्वर्टर.

ऑप्टिमाइज़ेशन के तरीके

ट्रेनिंग के बाद संख्या बढ़ाने के कई विकल्प हैं. यहाँ है विकल्पों और उनसे मिलने वाले फ़ायदों की खास जानकारी वाली टेबल:

तकनीक फ़ायदे हार्डवेयर
डाइनैमिक रेंज क्वांटाइज़ेशन चार गुना छोटा, दो गुना से तीन गुना स्पीडअप CPU
पूरा पूर्णांक क्वांटाइज़ेशन चार गुना छोटा, 3 गुना से ज़्यादा स्पीडअप सीपीयू, एज टीपीयू, माइक्रोकंट्रोलर्स
फ़्लोट16 क्वांटाइज़ेशन दोगुना छोटा, जीपीयू तेज़ी सीपीयू, जीपीयू

यहां दिए गए डिसिज़न ट्री की मदद से यह तय किया जा सकता है कि ट्रेनिंग के बाद किस क्वालिटी में डेटा देखा जा सकता है आपके लिए सबसे सही तरीका कौनसा है:

ट्रेनिंग के बाद के ऑप्टिमाइज़ेशन के विकल्प

कोई क्वांटाइज़ेशन नहीं

क्वांटाइज़ेशन के बिना TFLite मॉडल में बदलने का सुझाव दिया जाता है. शुरू करें अंक. इससे एक फ़्लोट TFLite मॉडल जनरेट होगा.

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
tflite_quant_model = converter.convert()

हमारा सुझाव है कि आप इसे शुरुआती चरण के तौर पर करें, ताकि इस बात की पुष्टि हो सके कि TF मॉडल के ऑपरेटर, TFLite के साथ काम करते हैं और इसका इस्तेमाल बाद की ट्रेनिंग के बाद, क्वांटाइज़ेशन की गड़बड़ियों को डीबग करने के लिए बेसलाइन क्वांटाइज़ेशन के तरीकों का इस्तेमाल करें. उदाहरण के लिए, अगर संख्यात्मक TFLite मॉडल तैयार करता है उम्मीद के मुताबिक नतीजे नहीं मिलते. हालांकि, float TFLite मॉडल सटीक है, लेकिन हम फ़िल्टर को सीमित कर सकते हैं TFLite ऑपरेटर के क्वांटाइज़्ड वर्शन में हुई गड़बड़ियों की वजह से आई समस्या.

डाइनैमिक रेंज क्वांटाइज़ेशन

डाइनैमिक रेंज क्वांटाइज़ेशन की सुविधा से, मेमोरी का कम इस्तेमाल होता है और कैलकुलेशन तेज़ी से होती है इसके लिए, आपको कैलिब्रेशन के लिए कोई प्रतिनिधि डेटासेट देने की ज़रूरत नहीं होती. यह क्वांटाइज़ेशन का टाइप, स्टैटिक तरीके से फ़्लोटिंग पॉइंट से सिर्फ़ वेट को गिनता है को पूर्णांक में बदल देता है, जो 8-बिट की सटीक जानकारी देता है:

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_quant_model = converter.convert()

अनुमान के दौरान इंतज़ार के समय को और कम करने के लिए, "डाइनैमिक-रेंज" ऑपरेटर 8-बिट की रेंज के आधार पर, ऐक्टिवेशन को डाइनैमिक तौर पर मापता है और परफ़ॉर्म करता है 8-बिट वेट और ऐक्टिवेशन के साथ कंप्यूटेशन (कंप्यूटेशन). यह ऑप्टिमाइज़ेशन इंतज़ार का समय, पूरी तरह से तय पॉइंट वाले अनुमानों के करीब होता है. हालांकि, आउटपुट अब भी फ़्लोटिंग पॉइंट का इस्तेमाल करके सेव किया जाता है, ताकि डाइनैमिक-रेंज ऑपरेशन की बढ़ी हुई स्पीड कम हो कंप्यूटेशन (हिसाब लगाना) की तुलना में ज़्यादा सटीक है.

पूर्ण पूर्णांक क्वांटाइज़ेशन

आपको इंतज़ार के समय में सुधार करने और सबसे ज़्यादा मेमोरी के इस्तेमाल में कमी लाने के साथ-साथ, यह पक्का करके पक्का करें कि डेवलपर सिर्फ़ इंटीजर डिवाइसों या एक्सीलेरेटर के साथ काम कर सकते हैं सभी मॉडल की गणित, पूर्णांक में होती है.

पूर्णांक की पूरी संख्या का इस्तेमाल करने के लिए, आपको रेंज को कैलिब्रेट करना होगा या उसका अनुमान लगाना होगा, उदाहरण के लिए, मॉडल में सभी फ़्लोटिंग-पॉइंट टेंसर का (कम से कम, ज़्यादा से ज़्यादा) मान का इस्तेमाल करें. कॉन्स्टेंट को नापसंद करें टेंसर, जैसे कि वेट और बायस, वैरिएबल टेंसर, जैसे कि मॉडल इनपुट, ऐक्टिवेशन (इंटरमीडिएट लेयर के आउटपुट) और मॉडल आउटपुट कैलिब्रेट नहीं किया जाता, जब तक कि हम कुछ अनुमान साइकल नहीं चलाते. इस वजह से, कन्वर्टर उन्हें कैलिब्रेट करने के लिए प्रतिनिधि डेटासेट की ज़रूरत होती है. यह डेटासेट छोटा हो सकता है ट्रेनिंग या पुष्टि के डेटा का सबसेट (करीब 100-500 सैंपल). इससे संदर्भ लें नीचे दिया गया representative_dataset() फ़ंक्शन.

TensorFlow 2.7 वर्शन में, प्रतिनिधि डेटासेट को इसके ज़रिए तय किया जा सकता है हस्ताक्षर शामिल करें, जैसा कि नीचे दिया गया है:

def representative_dataset():
  for data in dataset:
    yield {
      "image": data.image,
      "bias": data.bias,
    }

अगर TensorFlow के दिए गए मॉडल में एक से ज़्यादा हस्ताक्षर हैं, तो हस्ताक्षर कुंजियां तय करके एक से ज़्यादा डेटासेट की जानकारी दें:

def representative_dataset():
  # Feed data set for the "encode" signature.
  for data in encode_signature_dataset:
    yield (
      "encode", {
        "image": data.image,
        "bias": data.bias,
      }
    )

  # Feed data set for the "decode" signature.
  for data in decode_signature_dataset:
    yield (
      "decode", {
        "image": data.image,
        "hint": data.hint,
      },
    )

इनपुट टेंसर की सूची देकर, प्रतिनिधि डेटासेट जनरेट किया जा सकता है:

def representative_dataset():
  for data in tf.data.Dataset.from_tensor_slices((images)).batch(1).take(100):
    yield [tf.dtypes.cast(data, tf.float32)]

TensorFlow 2.7 वर्शन होने की वजह से, हमारा सुझाव है कि आप हस्ताक्षर पर आधारित तरीके का इस्तेमाल करें इनपुट टेंसर सूची-आधारित अप्रोच से बदलें, क्योंकि इनपुट टेंसर ऑर्डरिंग इन्हें आसानी से फ़्लिप किया जा सकता है.

टेस्टिंग के लिए, डमी डेटासेट का इस्तेमाल इस तरह किया जा सकता है:

def representative_dataset():
    for _ in range(100):
      data = np.random.rand(1, 244, 244, 3)
      yield [data.astype(np.float32)]

फ़्लोट फ़ॉलबैक के साथ पूर्णांक (डिफ़ॉल्ट फ़्लोट इनपुट/आउटपुट का इस्तेमाल करके)

किसी मॉडल को पूरी तरह से पूर्णांक में बदलने के लिए, फ़्लोट ऑपरेटर का इस्तेमाल तब करें, जब वे कोई पूर्णांक लागू नहीं होता (यह पक्का करने के लिए कि कन्वर्ज़न आसानी से हो), इसका इस्तेमाल करें यहां बताया गया तरीका अपनाएं:

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_dataset
tflite_quant_model = converter.convert()

सिर्फ़ पूर्णांक

केवल पूर्णांक वाले मॉडल बनाना, LiteRT के लिए माइक्रोकंट्रोलर्स और कोरल Edge TPU.

इसके अलावा, सिर्फ़ पूर्णांक में काम करने वाले डिवाइसों (जैसे कि 8-बिट) के साथ काम करना माइक्रोकंट्रोलर) और ऐक्सेलरेटर (जैसे, कोरल एज TPU) का इस्तेमाल किया जा सकता है, तो ऐसी स्थिति में इन्हें लागू किया जा सकता है इनपुट और आउटपुट के साथ सभी ऑपरेशन के लिए, पूर्णांक की पूरी संख्या का इस्तेमाल करें. ऐसा करने के लिए, यहां बताया गया तरीका अपनाएं:

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_dataset
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.int8  # or tf.uint8
converter.inference_output_type = tf.int8  # or tf.uint8
tflite_quant_model = converter.convert()

फ़्लोट16 क्वांटाइज़ेशन

वेट का आकलन करके, फ़्लोटिंग पॉइंट मॉडल का साइज़ कम किया जा सकता है float16, जो 16-बिट फ़्लोटिंग पॉइंट नंबर के लिए आईईईई मानक है. float16 को चालू करने के लिए वज़न की गणना करने के लिए, नीचे दिए गए तरीके का इस्तेमाल करें:

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.target_spec.supported_types = [tf.float16]
tflite_quant_model = converter.convert()

फ़्लोट16 क्वांटाइज़ेशन के फ़ायदे यहां दिए गए हैं:

  • यह मॉडल के साइज़ को आधा कम कर देता है, क्योंकि सभी वेट मूल साइज़).
  • इससे सटीक नतीजे बहुत कम मिलते हैं.
  • यह कुछ डेलिगेट के साथ काम करता है, जैसे कि जीपीयू डेलिगेट. यह सीधे float16 डेटा पर लागू होता है, जिसकी वजह से float32 के मुकाबले तेज़ी से एक्ज़ीक्यूशन किया जा सकता है कंप्यूटेशन.

float16 क्वांटाइज़ेशन के नुकसान के बारे में यहां बताया गया है:

  • यह लेटेंसी को इतना कम नहीं करता, जितना कि फ़िक्स्ड पॉइंट के गणित के क्वांटाइज़ेशन के समय को कम किया जाता है.
  • डिफ़ॉल्ट रूप से, float16 क्वांटाइज़्ड मॉडल "डिक्वांटाइज़" होगा वज़न की वैल्यू का इस्तेमाल करें. (ध्यान दें कि जीपीयू डेलिगेट काम नहीं करेगा क्योंकि यह float16 डेटा पर काम कर सकता है.)

सिर्फ़ पूर्णांक: 8-बिट वेट के साथ 16-बिट ऐक्टिवेशन (एक्सपेरिमेंट के तौर पर उपलब्ध)

यह एक एक्सपेरिमेंटल क्वांटाइज़ेशन स्कीम है. यह "सिर्फ़ पूर्णांक" की तरह है स्कीम, लेकिन ऐक्टिवेशन की संख्या उनकी रेंज से लेकर 16-बिट, वेट तक की मात्रा 8-बिट पूर्णांक में होती है और बायस की माप 64-बिट पूर्णांक में की जाती है. यह को 16x8 क्वांटाइज़ेशन कहा जाता है.

परफ़ॉर्मेंस को मापने की इस सुविधा का मुख्य फ़ायदा यह है कि इससे ज़्यादा सटीक नतीजे मिलते हैं काफ़ी बढ़ा है, लेकिन मॉडल के साइज़ को थोड़ा-बहुत बढ़ा सकता है.

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.representative_dataset = representative_dataset
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.target_spec.supported_ops = [tf.lite.OpsSet.EXPERIMENTAL_TFLITE_BUILTINS_ACTIVATIONS_INT16_WEIGHTS_INT8]
tflite_quant_model = converter.convert()

अगर इस मॉडल में कुछ ऑपरेटर के लिए 16x8 क्वांटाइज़ेशन की सुविधा काम नहीं करती है, तो मॉडल को फिर भी मापा जा सकता है, लेकिन काम न करने वाले ऑपरेटर फ़्लोट में रखे जाते हैं. कॉन्टेंट बनाने इसकी अनुमति देने के लिए, target_spec में नीचे दिया गया विकल्प जोड़ा जाना चाहिए. 

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.representative_dataset = representative_dataset
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.target_spec.supported_ops = [tf.lite.OpsSet.EXPERIMENTAL_TFLITE_BUILTINS_ACTIVATIONS_INT16_WEIGHTS_INT8,
tf.lite.OpsSet.TFLITE_BUILTINS]
tflite_quant_model = converter.convert()

इस्तेमाल के ऐसे उदाहरणों के उदाहरण जहां इस दस्तावेज़ में दी गई जानकारी को सटीक बनाने के लिए सुधार किए गए हैं क्वांटाइज़ेशन स्कीम में शामिल है:

  • सुपर रिज़ॉल्यूशन,
  • ऑडियो सिग्नल प्रोसेसिंग, जैसे कि ग़ैर-ज़रूरी आवाज़ें कम करना और बीमफ़ॉर्मिंग,
  • इमेज से ग़ैर-ज़रूरी आवाज़ें कम करने की सुविधा,
  • किसी एक इमेज से एचडीआर क्वालिटी में वीडियो बनाने की सुविधा.

नतीजों को आंकड़ों में बदलने की इस सुविधा का नुकसान है:

  • फ़िलहाल, अनुमान 8-बिट पूरे पूर्णांक से काफ़ी धीमा है, क्योंकि ऑप्टिमाइज़ किए गए कर्नेल को लागू न किया गया हो.
  • फ़िलहाल, यह मौजूदा हार्डवेयर ऐक्सेलरेटेड TFLite के साथ काम नहीं करता डेलिगेट.

इस क्वांटाइज़ेशन मोड के लिए ट्यूटोरियल देखें यहां पढ़ें.

मॉडल की सटीक जानकारी

ट्रेनिंग के बाद वज़न को मापा जा सकता है, इसलिए सही वज़न कम हो सकता है, खास तौर पर, छोटे नेटवर्क के लिए. पूरी तरह क्वांटाइज़ किए गए मॉडल में पहले से ट्रेनिंग दी गई है Kaggle पर खास नेटवर्क के लिए दिया गया है मॉडल को अपनाएं. यह जांच करने के लिए कि क्वांटाइज़्ड मॉडल कितना सटीक है अगर सटीक होने में किसी भी तरह की गिरावट आती है, तो उसे स्वीकार की जाने वाली सीमाओं के अंदर ही रखा जा सकता है. ऐसे कई टूल हैं जिनकी मदद से LiteRT मॉडल का आकलन करें सटीक.

इसके अलावा, अगर सटीक जानकारी में गिरावट बहुत ज़्यादा है, तो संख्या का इस्तेमाल करें पता है ट्रेनिंग को अपनाएं. हालांकि, ऐसा करने के लिए मॉडल ट्रेनिंग के दौरान बदलाव करना पड़ता है, ताकि नकली प्रॉडक्ट जोड़े जा सकें क्वांटाइज़ेशन नोड, जबकि इस पर पोस्ट-ट्रेनिंग क्वांटाइज़ेशन की तकनीकें पेज पर पहले से ट्रेन किए गए मॉडल का इस्तेमाल किया जा रहा हो.

क्वांटाइज़्ड टेंसर का प्रतिनिधित्व

8-बिट क्वांटाइज़ेशन, फ़्लोटिंग पॉइंट वैल्यू का अनुमान लगाने के लिए इनका इस्तेमाल करता है फ़ॉर्मूला का इस्तेमाल करें.

\[real\_value = (int8\_value - zero\_point) \times scale\]

प्रतिनिधित्व के दो मुख्य हिस्से होते हैं:

  • हर ऐक्सिस (यानी हर चैनल) या हर टेंसर के वज़न को int8 द्वारा दिखाया गया है [-127, 127] की रेंज में पूरक वैल्यू के तौर पर वैल्यू दी गई है. साथ ही, शून्य-पॉइंट 0 के बराबर है.

  • हर टेंसर के ऐक्टिवेशन/इनपुट को int8 दो की कॉम्प्लिमेंट वैल्यू से इसमें दिखाया जाता है रेंज [-128, 127], जिसकी रेंज में शून्य पॉइंट है [-128, 127].

हमारी क्वांटाइज़ेशन स्कीम के बारे में ज़्यादा जानने के लिए, कृपया क्वांटाइज़ेशन की हमारी स्कीम खास जानकारी. हार्डवेयर वेंडर, जो TensorFlow का इस्तेमाल करना चाहते हैं Lite के डेलिगेट इंटरफ़ेस को क्वांटाइज़ेशन स्कीम को लागू करने के लिए बढ़ावा दिया जाता है में बताया गया है.