-chlo-legalize-to-stablehlo

CHLO ऑपरेशन फ़्लो से StableHLO और Shape ऑपरेशन को कानूनी बनाता है

-shape-legalize-to-stablehlo

StableHLO में, आकार से जुड़े ऑपरेशन को कानूनी बनाना.

यह एक एक्सपेरिमेंटल पास है, जो शेप से जुड़े ऑपरेशन को StableHLO ऑपरेशन के लिए मान्य बनाता है.

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

-stablehlo-aggressive-folder

StableHLO ऑपरेशन को फ़ोल्ड करता है

विकल्प

-fold-float : Allow for potentially lossy computations using float type.

-stablehlo-aggressive-simplification

StableHLO ऑपरेशन को कैननिकल बनाता है

-stablehlo-canonicalize-dynamism

डाइनैमिक StableHLO ऑपरेशन को स्टैटिक ऑपरेशन में कैननिकल करता है.

अगर इन ऑपरेशन के सभी डाइनैमिक एलिमेंट असल में कॉन्स्टेंट हैं, तो DynamicReshapeOp जैसे डाइनैमिक StableHLO ऑपरेशन को, DynamicReshapeOp से ReshapeOp या DynamicBroadcastInDim से BroadcastInDim जैसे मिलते-जुलते स्टैटिक ऑपरेशन से बदल देता है.

  %c = stablehlo.constant dense<16> : tensor<1xi32>
  %0 = stablehlo.dynamic_broadcast_in_dim %cst, %c, dims = [] : (tensor<f32>, tensor<1xi32>) -> tensor<16xf32>

  ==>

  %0 = stablehlo.broadcast_in_dim %cst, dims = [] : (tensor<f32>) -> tensor<16xf32>

-stablehlo-compatibility-expander

StableHLO ऑपरेशन के लिए, कम्पैटिबिलिटी एक्सपैंडर.

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

यह ऑप्ट-इन पास क्यों है?

कभी-कभी, OpenXLA नेटवर्क में कुछ सामान्य पैटर्न को आसानी से मैनेज करने के लिए, StableHLO ऑपरेशन को बेहतर बनाया जाता है. इसमें TanOp जैसी चीज़ें शामिल हैं, जिनमें फ़्रेमवर्क और कंपाइलर की ज़्यादा सहायता होती है. साथ ही, इकट्ठा करने/बिखेरने वाले बैचिंग डाइमेंशन भी शामिल हैं, जिन्हें स्लाइस का इस्तेमाल करके दिखाया जा सकता है. हालांकि, इससे शर्डिंग करना ज़्यादा मुश्किल हो जाता है. नई सुविधाओं की इस कैटगरी के लिए, हम अपने-आप डाउनग्रेड करने की सुविधा नहीं देते. ऐसा इसलिए, क्योंकि इससे बाद में ऑप्टिमाइज़ेशन के लिए इस्तेमाल की जाने वाली अहम जानकारी मिट सकती है. इस पास का इस्तेमाल, टारगेट वर्शन के आधार पर इन ऑपरेशन को बढ़ाने के लिए किया जा सकता है. इससे, कम ऑप्टिमाइज़ किए गए कंपाइलेशन की कीमत पर, काम करने की क्षमता को बढ़ाया जा सकता है.

func.func @tan_op_non_complex(%arg0: tensor<4xf64>) -> tensor<4xf64> {
  %1 = stablehlo.tan %arg0 : tensor<4xf64>
  func.return %1 : tensor<4xf64>
}

==>

func.func @tan_op_non_complex(%arg0: tensor<4xf64>) -> tensor<4xf64> {
  %0 = stablehlo.sine %arg0 : tensor<4xf64>
  %1 = stablehlo.cosine %arg0 : tensor<4xf64>
  %2 = stablehlo.divide %0, %1 : tensor<4xf64>
  return %2 : tensor<4xf64>
}

विकल्प

-target : The target version. Must be a version of the form #.#.#.

-stablehlo-convert-to-signless

IR को बिना साइन वाले पूर्णांक में बदलने के लिए पास करें.

-stablehlo-legalize-composite-to-call

कॉम्पोज़िट ऑपरेशन को उनके डिकंपोज़िशन कॉल से बदलता है.

कंपोजिट ऑपरेशन को उनके डिकंपोज़िशन कॉल से बदलता है. उदाहरण के लिए, नीचे दिया गया:

stablehlo.composite "my_namespace.my_op" %arg0, %arg1 {
  decomposition = @bar,
  version = 1,
  composite_attributes = {
    "my_attribute": "my_value"
  }
}

यह बदल जाएगा:

func.call @bar(%arg0, %arg1)

"सिर्फ़" फ़्लैग का इस्तेमाल करके, कॉम्पोज़िट के किसी सबसेट को इस ट्रांसफ़ॉर्मेशन से बाहर रखा जा सकता है. उदाहरण के लिए:

stablehlo-opt --stablehlo-legalize-composite-to-call=except='foo.baz,foo.qux'

विकल्प

-except : Names of composites that should not be replaced with calls.

-stablehlo-legalize-deprecated-ops

ऐसे ऑपरेशन को कानूनी बनाना जो अब काम नहीं करते.

StableHLO v1.0 Opset Deprecations RFC (#2283) में, कई ग़ैर-ज़रूरी ऑपरेशन हटाने का सुझाव दिया गया है. इस पास की मदद से, अलग-अलग कंपाइलेशन पाइपलाइन में, ऑप्ट-आउट की वजह से कॉन्टेंट हटाए जाने के असर का आकलन किया जा सकता है. इसके लिए, लंबे समय से काम करने वाले टूल के साथ इन टूल को कानूनी तौर पर मंज़ूरी दी जाती है.

विकल्प

-fail-on-unused : Fail on (mostly) unused ops that are deprecated without any fallback.

-stablehlo-legalize-qdq-to-quantized-op

StableHLO के क्वांटिज़ किए गए ऑपरेशन में फ़्यूज़ (डि-क्वांटाइज़, फ़्लोटिंग-पॉइंट ऑपरेशन, और क्वांटाइज़) पैटर्न

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

func.func @add(%arg0: tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>>) -> tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>> {
  %0 = stablehlo.uniform_dequantize %arg0 : (tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>>) -> tensor<16x16xf32>
  %1 = stablehlo.abs %0 : tensor<16x16xf32>
  %2 = stablehlo.uniform_quantize %1 : (tensor<16x16xf32>) -> tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>>
  func.return %2 : tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>>
}

यह बदल जाएगा:

func.func @add(%arg0: tensor<16x16x!quant.uniform<u8:f32, 3.400000e+01:16>>) -> tensor<16x16x!quant.uniform<u8:f32, 3.400000e+01:16>> {
  %0 = stablehlo.uniform_dequantize %arg0 : (tensor<16x16x!quant.uniform<u8:f32, 3.400000e+01:16>>) -> tensor<16x16xf32>
  %1 = stablehlo.abs %0 : tensor<16x16xf32>
  %2 = stablehlo.abs %arg0 : tensor<16x16x!quant.uniform<u8:f32, 3.400000e+01:16>>
  %3 = stablehlo.uniform_quantize %1 : (tensor<16x16xf32>) -> tensor<16x16x!quant.uniform<u8:f32, 3.400000e+01:16>>
  return %2 : tensor<16x16x!quant.uniform<u8:f32, 3.400000e+01:16>>
}

-stablehlo-legalize-quant-to-math

StableHLO के क्वांटिज़ किए गए ऑपरेशन को StableHLO के प्राइमटिव मैथ ऑपरेशन में बदलना.

UniformQuantized टाइप का इस्तेमाल करने वाले StableHLO प्रोग्राम को, अर्थ के हिसाब से बराबर इंटिजर मैथ ऑपरेशन में बदलें.

func.func @add(%arg0: tensor<!quant.uniform<i8:f32,1.0:0>>, %arg1: tensor<!quant.uniform<i8:f32,2.0:1>>) ->  tensor<!quant.uniform<i8:f32,3.0:2>> {
  %0 = "stablehlo.add"(%arg0, %arg1) : (tensor<!quant.uniform<i8:f32,1.0:0>>, tensor<!quant.uniform<i8:f32,2.0:1>>) -> tensor<!quant.uniform<i8:f32,3.0:2>>
  func.return %0 : tensor<!quant.uniform<i8:f32,3.0:2>>
}

यह बदल जाएगा:

func.func @add(%arg0: tensor<i8>, %arg1: tensor<i8>) -> tensor<i8> {
  %0 = stablehlo.convert %arg0 : (tensor<i8>) -> tensor<f32>
  %cst = stablehlo.constant dense<0.333333343> : tensor<f32>
  %1 = chlo.broadcast_multiply %0, %cst : (tensor<f32>, tensor<f32>) -> tensor<f32>
  %cst_0 = stablehlo.constant dense<2.000000e+00> : tensor<f32>
  %2 = chlo.broadcast_add %1, %cst_0 : (tensor<f32>, tensor<f32>) -> tensor<f32>
  %3 = stablehlo.round_nearest_even %2 : tensor<f32>
  %4 = stablehlo.convert %3 : (tensor<f32>) -> tensor<i32>
  %5 = stablehlo.convert %arg1 : (tensor<i8>) -> tensor<f32>
  %cst_1 = stablehlo.constant dense<0.666666686> : tensor<f32>
  %6 = chlo.broadcast_multiply %5, %cst_1 : (tensor<f32>, tensor<f32>) -> tensor<f32>
  %cst_2 = stablehlo.constant dense<1.33333337> : tensor<f32>
  %7 = chlo.broadcast_add %6, %cst_2 : (tensor<f32>, tensor<f32>) -> tensor<f32>
  %8 = stablehlo.round_nearest_even %7 : tensor<f32>
  %9 = stablehlo.convert %8 : (tensor<f32>) -> tensor<i32>
  %c = stablehlo.constant dense<2> : tensor<i32>
  %10 = chlo.broadcast_add %4, %9 : (tensor<i32>, tensor<i32>) -> tensor<i32>
  %11 = chlo.broadcast_subtract %10, %c : (tensor<i32>, tensor<i32>) -> tensor<i32>
  %c_3 = stablehlo.constant dense<-128> : tensor<i32>
  %c_4 = stablehlo.constant dense<127> : tensor<i32>
  %12 = stablehlo.clamp %c_3, %11, %c_4 : tensor<i32>
  %13 = stablehlo.convert %12 : (tensor<i32>) -> tensor<i8>
  return %13 : tensor<i8>
}

-stablehlo-legalize-quantized-op-to-qdq

क्वांटाइज़ किए गए StableHLO ऑपरेशन को (डिक्वांटाइज़, फ़्लोटिंग-पॉइंट ऑपरेशन, और क्वांटाइज़) पैटर्न में बांटें.

एक जैसे क्वांटाइज़/डेकवांटाइज़ ऑपरेशन का इस्तेमाल करके, StableHLO क्वांटाइज़ किए गए प्रोग्राम को अलग-अलग हिस्सों में बांटें. उदाहरण के लिए, यह प्रोग्राम

func.func @add(%arg0: tensor<!quant.uniform<i8:f32,1.0:0>>, %arg1: tensor<!quant.uniform<i8:f32,2.0:1>>) ->  tensor<!quant.uniform<i8:f32,3.0:2>> {
  %0 = "stablehlo.add"(%arg0, %arg1) : (tensor<!quant.uniform<i8:f32,1.0:0>>, tensor<!quant.uniform<i8:f32,2.0:1>>) -> tensor<!quant.uniform<i8:f32,3.0:2>>
  func.return %0 : tensor<!quant.uniform<i8:f32,3.0:2>>
}

यह बदल जाएगा:

func.func @add(%arg0: tensor<!quant.uniform<i8:f32, 1.000000e+00>>, %arg1: tensor<!quant.uniform<i8:f32, 2.000000e+00:1>>) -> tensor<!quant.uniform<i8:f32, 3.000000e+00:2>> {
  %0 = stablehlo.uniform_dequantize %arg0 : (tensor<!quant.uniform<i8:f32, 1.000000e+00>>) -> tensor<f32>
  %1 = stablehlo.uniform_dequantize %arg1 : (tensor<!quant.uniform<i8:f32, 2.000000e+00:1>>) -> tensor<f32>
  %2 = stablehlo.add %0, %1 : tensor<f32>
  %3 = stablehlo.uniform_quantize %2 : (tensor<f32>) -> tensor<!quant.uniform<i8:f32, 3.000000e+00:2>>
  return %3 : tensor<!quant.uniform<i8:f32, 3.000000e+00:2>>
}

-stablehlo-legalize-to-vhlo

StableHLO को VHLO में बदलने की प्रक्रिया को कानूनी बनाना.

-stablehlo-refine-arguments

मुख्य फ़ंक्शन के आर्ग्युमेंट के शेप को बेहतर बनाता है.

इनपुट टाइप सिग्नेचर का इस्तेमाल करके, मुख्य फ़ंक्शन के आर्ग्युमेंट में बदलाव करता है. आर्ग्युमेंट को custom_call @stablehlo.shape_refinement_operand_wrapper में रैप करता है, ताकि आकार को बेहतर बनाने की प्रोसेस शुरू होने से पहले आईआर मान्य रहे.

func.func public @main(%arg0: tensor<?xf32>) -> tensor<?xf32> {
  ...
}

==>

func.func public @main(%arg0: tensor<16xf32>) -> tensor<?xf32> {
  %c = stablehlo.constant dense<16> : tensor<1xi64>
  %0 = stablehlo.custom_call @stablehlo.shape_refinement_operand_wrapper(%arg0, %c) {...}
    : (tensor<16xf32>, tensor<1xi64>) -> tensor<?xf32>
  ...

refinedTypesOption का इस्तेमाल, बेहतर किए गए टाइप की सूची तय करने के लिए किया जा सकता है. इसे --types='tensor<...>,tensor<...>' के साथ MLIR में बताया जा सकता है या पास बनाने के तरीके में पास किया जा सकता है. बेहतर बनाने के तरीके की सूची में, बेहतर बनाए जा रहे main तरीके के हर आर्ग्युमेंट का टाइप बताना ज़रूरी है.

विकल्प

-types : The new types to be used for the main function's arguments, specified as an MLIR TypeRange 'tensor<1x2xf32>, ...'

-stablehlo-refine-shapes

StableHLO प्रोग्राम में आकृतियों को बेहतर बनाता है.

ऑपरेशन में आकार को बेहतर बनाने वाले StableHLO प्रोग्राम के बारे में जानकारी.

इस पास का मुख्य इस्तेमाल, डाइनैमिक आकार वाले प्रोग्राम को स्टैटिक आकार में बदलना है. अगर डाइनैमिक आकार वाले StableHLO प्रोग्राम का स्ट्रक्चर सही है, तो उसके आर्ग्युमेंट टाइप को डाइनैमिक आकार से स्टैटिक आकार में अपडेट करें. साथ ही, इस पास को चलाने से, प्रोग्राम में स्टैटिक आकार का इस्तेमाल किया जाएगा.

यह पास, custom_call @shape_refinement_operand_wrapper को हटा देता है. ऐसा करने के लिए, यह नतीजे के इस्तेमाल को ऑपरेंड से सीधे बदल देता है. साथ ही, पूरे प्रोग्राम में स्टैटिक शेप को प्रॉपेगेट करता है.

  %c = stablehlo.constant dense<16> : tensor<1xi64>
  %0 = stablehlo.custom_call @stablehlo.shape_refinement_operand_wrapper(%arg0, %c) {...}
      : (tensor<16xf32>, tensor<1xi64>) -> tensor<?xf32>
  %1 = stablehlo.add %0, %0 : tensor<?xf32>

  ==>

  %1 = stablehlo.add %arg0, %arg0 : tensor<16xf32>

आकार को बेहतर बनाने के लिए मान्य मॉड्यूल में ये प्रॉपर्टी होनी चाहिए:

• सभी डाइनैमिक शेप, सिर्फ़ इनपुट शेप पर निर्भर करते हैं. इनपुट ऐरे के कॉन्टेंट पर कोई शेप डिपेंड नहीं करता. हम उन ऑपरेशन को dimension ऑपरेशन कहते हैं जो सिर्फ़ इनपुट शेप (उदाहरण के लिए, stablehlo.get_dimension_size के तौर पर दिए गए) या ग्लोबल कॉन्स्टेंट पर ट्रांज़िटिव तरीके से निर्भर करते हैं. जैसे, सिंबल वाले पूर्णांकों की हल की गई वैल्यू (यानी टेंसर : A = 5). इंटर-प्रोसेड्यूरल कॉन्स्टेंट फ़ोल्डिंग की मदद से, सभी डाइमेंशन वैल्यू को कॉन्स्टेंट में बदला जा सकता है.
• इंटरमीडिएट फ़ंक्शन, आर्ग्युमेंट की सूची की शुरुआत में कई टोकन आर्ग्युमेंट (टाइप !stablehlo.token) ले सकते हैं.इसके बाद, कुछ ग्लोबल कॉन्स्टेंट आर्ग्युमेंट आते हैं, जो कॉन्स्टेंट इंटिजर स्केलर होते हैं. जैसे, सिंबल वाले इंटिजर की हल की गई वैल्यू (जैसे, टेंसर : A = 5).
• कुछ इंटरमीडिएट फ़ंक्शन, वैल्यू पर आधारित गणना दिखा सकते हैं. जैसे, symint वैल्यू पर floordiv. इन फ़ंक्शन के बारे में, बेहतर बनाने के बाद सिर्फ़ कॉन्स्टेंट वैल्यू दिखाने से पता चलता है. ये फ़ंक्शन इनलाइन किए जाते हैं.
• किसी एक फ़ंक्शन के सभी कॉल, एक ही आर्ग्युमेंट शेप में रिज़ॉल्व होते हैं. साथ ही, कोई रिकर्सिव / को-रिकर्सिव फ़ंक्शन कॉल नहीं किया जाता. ### -vhlo-legalize-to-stablehlo

VHLO को StableHLO में बदलने की प्रक्रिया को कानूनी बनाना.

-vhlo-to-version

VHLO के वर्शन के बीच बदलाव करना.

विकल्प

-target : The target version. Must be a version of the form #.#.# .