StableHLO क्वांटाइज़ेशन

StableHLO में क्वॉन्टाइज़ेशन के टाइप

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

StableHLO में क्वांटीकरण, LiteRT क्वांटीकरण के स्पेसिफ़िकेशन के मुताबिक होता है. इसमें एक जैसा क्वांटीकरण स्कीम इस्तेमाल किया जाता है. साथ ही, इसमें पर-टेंसर और पर-ऐक्सिस क्वांटीकरण, दोनों के लिए सहायता उपलब्ध होती है. यह एमएलआईआर के Quant dialect से टाइप एक्सप्रेशन इनहेरिट करता है. इससे, क्वांटाइज़ किए गए डेटा टाइप को दिखाने का एक स्टैंडर्ड तरीका मिलता है.

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

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

यूनिफ़ॉर्म क्वांटाइज़ेशन में, ओरिजनल फ़्लोटिंग-पॉइंट वैल्यू (real_value) और क्वांटाइज़ की गई पूर्णांक वैल्यू (quantized_value) के बीच का संबंध यह है:

real_value = scale * (quantized_value - zero_point)

हर टेंसर के हिसाब से क्वांटाइज़ेशन

पर-टेंसर क्वांटाइज़ेशन में, टेंसर में मौजूद सभी वैल्यू के लिए एक ही स्केल और ज़ीरो पॉइंट का इस्तेमाल किया जाता है. हर-टेंसर के हिसाब से क्वांटाइज़ किए गए टाइप को StableHLO में इस तरह दिखाया जाता है:

quant.uniform scale:zero_point>

उदाहरण: !quant.uniform<i8:f32, 0.01:50>

यह 8-बिट पूर्णांक (i8) को दिखाता है. इसका इस्तेमाल, 0.01 के स्केल और 50 के शून्य पॉइंट का इस्तेमाल करके, 32-बिट फ़्लोटिंग-पॉइंट नंबर (f32) को सेव करने के लिए किया जाता है.

हर ऐक्सिस के हिसाब से क्वांटाइज़ेशन

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

मान लें कि डाइमेंशन साइज़ [4, 3, 2] वाला एक टेंसर t है. हम इस टेंसर को दूसरे डाइमेंशन (quantized_dimension = 1) के हिसाब से क्वांटाइज़ करते हैं. इसका मतलब है कि हमारे पास तीन स्लाइस होंगे, क्योंकि दूसरे डाइमेंशन का साइज़ 3 है. हर स्लाइस का अपना स्केल और ज़ीरो पॉइंट होगा:

t[:, 0, :]: This slice gets scale[0] and zero_point[0].
t[:, 1, :]: This slice gets scale[1] and zero_point[1].
t[:, 2, :]: This slice gets scale[2] and zero_point[2].

StableHLO में, हर ऐक्सिस के हिसाब से क्वांटाइज़ किए गए टाइप को इस तरह दिखाया जाता है:

quant.uniform {scale0:zero_point0, scale1:zero_point1, ...}>

यहां scale:zero_point की लंबाई, शामिल किए गए टेंसर के quantized_dimension के साथ स्लाइस की संख्या से मेल खाती है.

उदाहरण: tensor<4x3x2x!quant.uniform<i8:f32:1, {0.2:20, 0.1:10, 0.3:30}>>

StableHLO में क्वांटाइज़ेशन पास

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

stablehlo-legalize-qdq-to-quantized-op

यह पास, क्वांटाइज़ किए गए मॉडल में एक सामान्य पैटर्न को जोड़ता है. इसमें डीक्वांटाइज़ ऑपरेशन के बाद फ़्लोटिंग-पॉइंट ऑपरेशन और आखिर में क्वांटाइज़ ऑपरेशन को एक ही क्वांटाइज़ ऑपरेशन में बदल दिया जाता है. details

stablehlo-legalize-quantized-op-to-qdq

यह पास, पिछले पास से उलट काम करता है. यह क्वांटाइज़ किए गए ऑपरेशन को, डीक्वांटाइज़, फ़्लोटिंग-पॉइंट ऑपरेशन, और क्वांटाइज़ ऑपरेशन के बराबर के क्रम में बदलता है. जानकारी

stablehlo-legalize-quant-to-math

यह पास, पूर्णांक टाइप पर क्वांटाइज़ किए गए टाइप के StableHLO ऑपरेशनों को उनके बराबर के ऑपरेशनों में बदलता है. यह स्टैंडर्ड मैथमैटिकल ऑपरेशंस का इस्तेमाल करके, क्वांटाइज़ेशन अंकगणित को लागू करता है. यह डीकंपोज़िशन उन सिस्टम के लिए फ़ायदेमंद है जो नेटिव तौर पर क्वांटाइज़ेशन का समर्थन नहीं करते. हालांकि, वे क्वांटाइज़ेशन अंकगणित का इस्तेमाल करके, क्वांटाइज़ किए गए मॉडल के सिमैंटिक को दिखा सकते हैं. जानकारी

stablehlo-quant-legalize-to-tosa-rescale

StableHLO, क्वांटीकृत ऑपरेशनों को TOSA डायलेक्ट में उनके संबंधित प्रज़ेंटेशन के लिए कानूनी तौर पर मान्य करने की सुविधा देता है. इस कानूनी समझौते से, StableHLO और TOSA के बीच कंपैटिबिलिटी और इंटरऑपरेबिलिटी (दूसरे सिस्टम के साथ काम करने) को बेहतर बनाने में मदद मिलती है. यह पास, StableHLO के क्वांटाइज़ किए गए ऑपरेशनों को StableHLO और TOSA ऑपरेशनों के कॉम्बिनेशन में बदलता है. इसमें TOSA डायलेक्ट का इस्तेमाल मुख्य रूप से rescale ऑपरेशन के लिए किया जाता है. क्वांटाइज़ की गई वैल्यू के स्केल और ज़ीरो पॉइंट को अडजस्ट करने में tosa.rescale op की अहम भूमिका होती है. इससे TOSA फ़्रेमवर्क में, क्वांटाइज़ किए गए डेटा को सटीक तरीके से दिखाया जा सकता है. जानकारी

tosa-rescale-legalize-to-stablehlo

यह पास, TOSA के रीस्केल ऑपरेशन को StableHLO के प्रिमिटिव गणित ऑपरेशन में बदलता है. इस पास का मुख्य इस्तेमाल, StableHLO इंटरप्रेटर को TOSA rescale ऑपरेशंस वाले प्रोग्राम का आकलन करने की अनुमति देना है. ज़्यादा जानकारी

क्वांटाइज़ किए गए प्रोग्राम का आकलन करना

StableHLO रेफ़रंस इंटरप्रेटर, क्वॉन्टाइज़ेशन वाले ऑपरेशन वाले प्रोग्राम को आसानी से एक्ज़ीक्यूट कर सकता है. ऐसा करने के लिए, यह प्रोग्राम को सबसे पहले सिर्फ़ पूर्णांकों का इस्तेमाल करके, उसके बराबर के फ़ॉर्मैट में बदलता है. इस प्रोसेस में, कंपाइलर के कई पास शामिल होते हैं. ये पास, प्रोग्राम को इंटरप्रेट करने से पहले उसे बदलते हैं.

असल में, इंटरप्रेटर stablehlo-legalize-quant-to-math पास का इस्तेमाल करके, क्वांटाइज़ किए गए ऑपरेशनों को उनके इंटिजर अंकगणित के हिसाब से लागू करता है. इस पास में, CHLO ब्रॉडकास्ट ऑपरेशंस को पेश किया गया है. इनका इस्तेमाल, स्केल मल्टिप्लिकेशन/डिविज़न और ज़ीरो-पॉइंट एडिशन को मैनेज करने के लिए किया जाता है. StableHLO इंटरप्रेटर के साथ काम करने के लिए, इन CHLO ऑपरेशनों को StableHLO ऑपरेशनों में बदल दिया जाता है. इससे शेप से जुड़ी कार्रवाइयां शुरू होती हैं. इसके बाद, कैननिकल बनाने की प्रोसेस के कई चरणों का इस्तेमाल करके, उन्हें कैननिकल बनाया जाता है और ऑप्टिमाइज़ किया जाता है.

इस प्रोसेस में शामिल पास का पूरा क्रम यहां दिया गया है:

stablehlo-legalize-quant-to-math
chlo-legalize-to-stablehlo
canonicalize
shape-legalize-to-stablehlo
stablehlo-canonicalize-dynamism

क्वांटाइज़ किए गए टेस्ट केस

StableHLO, क्वॉन्टाइज़ेशन की प्रोसेस की पुष्टि करने के लिए, क्वॉन्टाइज़ किए गए टेस्ट केस का एक पूरा सुइट उपलब्ध कराता है. इससे यह पुष्टि की जा सकती है कि क्वॉन्टाइज़ेशन की प्रोसेस सही तरीके से काम कर रही है या नहीं. ये टेस्ट केस, यूनिट टेस्ट के तौर पर काम करते हैं. इनमें, क्वॉन्टाइज़ेशन के अलग-अलग तरीकों के साथ StableHLO के ऑपरेशनों को शामिल किया जाता है.

क्वांटाइज़ किए गए टेस्ट केस का सामान्य उदाहरण इस तरह दिखता है

func.func @main() -> tensor<11xf32> {
    %operand_0 = stablehlo.constant dense<...> : tensor<11xf32>
    %operand_1 = stablehlo.constant dense<...> : tensor<11xf32>
    %golden = stablehlo.constant dense<...> : tensor<11xf32>

    %0 = stablehlo.uniform_quantize %operand_0 : (tensor<11xf32>) -> tensor<11x!quant.uniform<i8:f32, 0.3>>
    %1 = stablehlo.uniform_quantize %operand_1 : (tensor<11xf32>) -> tensor<11x!quant.uniform<i8:f32, 0.3>>

    %2 = stablehlo.add %1, %0 : tensor<11x!quant.uniform<i8:f32, 0.3>>

    %result = stablehlo.uniform_dequantize %2 : (tensor<11x!quant.uniform<i8:f32, 0.3>>) -> tensor<11xf32>

    %4 = stablehlo.custom_call @check.eq(%golden, %result) : (tensor<11xf32>, tensor<11xf32>) -> tensor<i1>

    return %3 : tensor<11xf32>
  }

और इसमें ये शामिल हैं:

• इनपुट डेटा: कार्रवाई के लिए, इनपुट की प्रतिनिधि वैल्यू.
• गोल्डन आउटपुट: इनपुट डेटा पर लागू होने पर, ऑपरेशन का अनुमानित आउटपुट. यह StableHLO रेफ़रंस इंटरप्रेटर और HLO इवैल्यूएटर के मुताबिक होता है.

ये टेस्ट केस इनके लिए अहम हैं:

• StableHLO के क्वॉन्टाइज़ेशन की पुष्टि करना: यह पक्का करना कि StableHLO के ऑपरेशन के क्वॉन्टाइज़ेशन का तरीका, उम्मीद के मुताबिक हो.
• क्रॉस-वैलडेशन: StableHLO क्वांटाइज़ेशन की तुलना, अन्य इंप्लीमेंटेशन या फ़्रेमवर्क से करना.
• डीबगिंग और डेवलपमेंट: क्वांटाइज़ेशन की नई सुविधाओं को डेवलप करने या उन्हें ऑप्टिमाइज़ करने में मदद करना.