-chlo-legalize-to-stablehlo

CHLO ऑपरेशंस फ़्लो से StableHLO और शेप ऑपरेशंस में बदलने की अनुमति देता है

-shape-legalize-to-stablehlo

शेप से जुड़े ऑपरेशनों को StableHLO के साथ कानूनी तौर पर मान्य करें.

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

ऑप्शनल पास के ज़रिए शेप और डेटा कंप्यूटेशन को एक साथ लाने से, StableHLO के इकोसिस्टम के लिए, कंपाइलेशन पाइपलाइन का इस्तेमाल करना आसान हो जाएगा. ये पाइपलाइन, डाइनैमिज़्म को मॉडल करने के लिए 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-check-shape-assertions

_Check stablehlo.custom_call @shapeassertion ops.

shape_assertion कस्टम कॉल की पुष्टि करें.

शेप असर्शन, StableHLO में डाइनैमिक डाइमेंशन पर मौजूद पाबंदियों की पुष्टि करते हैं. उदाहरण के लिए, अगर किसी फ़्रेमवर्क को DimA < 2 की शर्त लागू करनी है, तो यह आईआर जारी किया जा सकता है:

%dimA = <get_dimension_size or input arg> : tensor<i32>
%c2 = stablehlo.constant dense<2> : tensor<i32>
%is_lt = stablehlo.compare LT %dimA, %c2 : tensor<i1>
stablehlo.custom_call @shape_assertion(%is_lt) { error_message = "DimA must be less than 2" }

पास होने के बाद, अगर शेप सही हैं, तो stablehlo.custom_call हटा दिया जाएगा.

विकल्प

-enable-shape-assertions : Whether shape assertions may generate errors.

-stablehlo-compatibility-expander

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

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

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

कभी-कभी, OpenXLA के इकोसिस्टम में कुछ सामान्य पैटर्न को आसानी से हैंडल करने के लिए, StableHLO op के बेहतर वर्शन का इस्तेमाल किया जाता है. इसमें 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-complex-math-expander

StableHLO में मुश्किल गणितीय ऑपरेशनों के लिए एक्सपैंडर.

StableHLO की कॉम्प्लेक्स मैथमैटिकल ऑपरेशंस, StableHLO की रियल मैथमैटिकल ऑपरेशंस का इस्तेमाल करके की गई डीकंपोज़िशन होती हैं.

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

func.func @sqrt_op_complex(%arg0: tensor<4xcomplex<f64>>) -> tensor<4xcomplex<f64>> {
  %1 = stablehlo.sqrt %arg0 : tensor<4xcomplex<f64>>
  func.return %1 : tensor<4xcomplex<f64>>
}

==>

func.func @sqrt_op_complex(%arg0: tensor<4xcomplex<f64>>) -> tensor<4xcomplex<f64>> {
  TBD
  return %2 : tensor<4xcomplex<f64>>
}

-stablehlo-convert-to-signless

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

-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)

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

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 प्रिमिटिव मैथ ऑप्स में बदलें.

यूनिफ़ॉर्मक्वांटाइज़्ड टाइप का इस्तेमाल करके, 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 में बदलना.

VHLO में, StableHLO को ops के सबसे नए वर्शन के साथ कानूनी तौर पर इस्तेमाल करने की अनुमति दें. इसके बाद, इन ऑपरेशनों को VhloToVersionPass का इस्तेमाल करके, VHLO के पुराने वर्शन पर डाउनग्रेड किया जा सकता है, ताकि वे आगे के वर्शन के साथ काम कर सकें.

stablehlo.exponential %[[ARG0]] <{result_accuracy = DEFAULT}> : tensor<f32>
# ====>
"vhlo.exponential_v2"(%[[ARG0]]) <{result_accuracy = #vhlo.DEFAULT_v1}> : !vhlo.tensor_v1<!vhlo.f32_v1>

VHLO का इस्तेमाल, आगे और पीछे की ओर कंपैटिबिलिटी बनाए रखने के लिए कैसे किया जाता है, इस बारे में पूरी जानकारी के लिए vhlo.md > The VHLO dialect देखें.

विकल्प

-allow-other-dialects : Allow serialization to use other (potentially unstable) dialects, inserts unrealized casts between dialects.

-stablehlo-refine-arguments

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

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

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<...>' के साथ तय किया जा सकता है या पास बनाने के तरीके में पास किया जा सकता है. रीफ़ाइनमेंट टाइप की सूची में, 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 के तौर पर दिया गया) या ग्लोबल कॉन्स्टेंट, जैसे कि सिंबॉलिक पूर्णांकों की हल की गई वैल्यू (यानी कि tensor : A = 5) पर निर्भर करती हैं. सभी डाइमेंशन वैल्यू को इंटर-प्रोसीजरल कॉन्स्टेंट फ़ोल्डिंग के ज़रिए कॉन्स्टेंट में बदला जा सकता है.
  • इंटरमीडिएट फ़ंक्शन, आर्ग्युमेंट की सूची की शुरुआत में कई टोकन आर्ग्युमेंट (टाइप !stablehlo.token) ले सकते हैं.इसके बाद, कुछ ग्लोबल कॉन्स्टेंट आर्ग्युमेंट होते हैं, जो कॉन्स्टेंट पूर्णांक स्केलर होते हैं. जैसे, सिंबॉलिक पूर्णांकों की हल की गई वैल्यू (यानी कि tensor : A = 5).
  • कुछ इंटरमीडिएट फ़ंक्शन, ग्लोबल कॉन्स्टेंट पर कंप्यूटेशन दिखा सकते हैं. जैसे, symint वैल्यू पर floordiv. इन फ़ंक्शन के बारे में सिर्फ़ यह बताया जाता है कि ये वैल्यू को बेहतर बनाने के बाद, कॉन्स्टेंट वैल्यू दिखाते हैं. इन फ़ंक्शन को इनलाइन किया जाता है.
  • किसी एक फ़ंक्शन के सभी कॉल, एक ही तरह के आर्ग्युमेंट शेप में बदलते हैं. साथ ही, कोई भी रिकर्सिव / को-रिकर्सिव फ़ंक्शन कॉल नहीं किया जाता है.

-stablehlo-wrap-in-composite

यह फ़ंक्शन, कंपोज़िट न किए गए StableHLO ऑप को कंपोज़िट ऑप में रैप करता है.

यह फ़ंक्शन, StableHLO ऑपरेशंस को stablehlo.composite ऑपरेशंस में रैप करता है.

उदाहरण के लिए, एक सामान्य StableHLO प्रोग्राम देखें:

func.func @main(%arg0 : tensor<2xf32>, %arg1 : tensor<2xf32>) -> tensor<2xf32> {
  %0 = stablehlo.add %arg0, %arg1 : tensor<2xf32>
  return %0 : tensor<2xf32>
}

इस पास को stablehlo.add रैप करने की कार्रवाइयों पर लागू करने से, यह प्रोग्राम मिलेगा:

func.func @main(%arg0: tensor<2xf32>, %arg1: tensor<2xf32>) -> tensor<2xf32> {
  %0 = stablehlo.composite "stablehlo.add" %arg0, %arg1 {decomposition = @stablehlo.add.impl} : (tensor<2xf32>, tensor<2xf32>) -> tensor<2xf32>
  return %0 : tensor<2xf32>
}
func.func private @stablehlo.add.impl(%arg0: tensor<2xf32>, %arg1: tensor<2xf32>) -> tensor<2xf32> {
  %0 = stablehlo.add %arg0, %arg1 : tensor<2xf32>
  return %0 : tensor<2xf32>
}

ध्यान दें:

  • जनरेट किए गए stablehlo.composite ऑपरेशन के name एट्रिब्यूट की वैल्यू हमेशा उस ओरिजनल ऑपरेशन के नाम के बराबर होगी जिसे रैप किया गया था. उदाहरण के लिए, अगर आपने stablehlo.add ऑपरेशन को रैप किया है, तो कंपोज़िट का नाम भी "stablehlo.add" होगा.
  • ओरिजनल ऑपरेशन (stablehlo.composite ऑपरेशन के decomposition एट्रिब्यूट से रेफ़र किया गया) को शामिल करने वाले प्राइवेट फ़ंक्शन का नाम, <op_name>.impl[.N] पैटर्न का इस्तेमाल करके रखा जाएगा. इसमें <op_name>, ओरिजनल ऑपरेशन का नाम है और N, एक यूनीक पूर्णांक आइडेंटिफ़ायर है. इसे मॉड्यूल में नाम से जुड़े टकराव को रोकने के लिए जनरेट किया जाता है.

इस पास का इस्तेमाल दो अलग-अलग तरीकों से किया जा सकता है:

पहला मोड: कमांड-लाइन का इस्तेमाल

इस मोड का इस्तेमाल डीबग करने या टेस्टिंग के लिए किया जाता है. ऐसा इसलिए, क्योंकि यह जनरेट की गई stablehlo.composite कार्रवाइयों के एट्रिब्यूट पर कम से कम कंट्रोल देता है. यह op-names (कार्रवाइयों के नामों की कॉमा लगाकर अलग की गई सूची) विकल्पों का इस्तेमाल करके तय की गई कार्रवाइयों के सभी इंस्टेंस को रैप करता है. नई बनाई गई stablehlo.composite कार्रवाई के एट्रिब्यूट, ओरिजनल कार्रवाई के एट्रिब्यूट जैसे ही होंगे.

इस्तेमाल का उदाहरण:

stablehlo-opt input.mlir --stablehlo-wrap-in-composite=op-names='stablehlo.add,stablehlo.mul' -o output.mlir

दूसरा मोड: प्रोग्राम के हिसाब से पूरे मॉड्यूल को रैप करना और एट्रिब्यूट को पसंद के मुताबिक मैनेज करना

यह मोड, पूरे मॉड्यूल के लिए प्रोग्राम के हिसाब से रैपिंग की सुविधा देता है. इससे यह तय करने में मदद मिलती है कि किन कार्रवाइयों को रैप किया जाए और उनके एट्रिब्यूट क्या हों. इसके लिए, createStablehloWrapInCompositePass एपीआई का इस्तेमाल किया जाता है. यह CompositeAttributeProviderMap को आर्ग्युमेंट के तौर पर लेता है.

CompositeAttributeProviderMap एक मैप है. इससे यह तय होता है कि रैपिंग के लिए किन कार्रवाइयों को शामिल किया जाना चाहिए और उनके एट्रिब्यूट को कैसे हैंडल किया जाना चाहिए. इसका सिमैंटिक इस तरह है:

  • कुंजियां (mlir::TypeID): MLIR ऑपरेशन की TypeID. अगर किसी ऑपरेशन का TypeID मैप में मौजूद किसी कुंजी से मेल खाता है, तो उसे रैप करने के लिए चुना जा सकता है.
  • वैल्यू (LAMBDA फ़ंक्शन): std::function<std::optional<NamedAttrList>(Operation*)> टाइप का LAMBDA फ़ंक्शन. इस फ़ंक्शन को हर उम्मीदवार कार्रवाई पर लागू किया जाता है.
    • इनपुट: एक mlir::Operation*, जो TypeID कुंजी से जुड़े ऑपरेशन टाइप का इंस्टेंस है.
    • रिटर्न वैल्यू: एक std::optional<NamedAttrList>.
      • अगर लैंबडा, NamedAttrList (std::optional में रैप किया गया) दिखाता है, तो ऑपरेशन को stablehlo::composite ऑपरेशन में रैप किया जाता है. साथ ही, दिखाए गए एट्रिब्यूट का इस्तेमाल, कंपोज़िट के एट्रिब्यूट सेट करने के लिए किया जाता है.
      • अगर लैम्डा std::nullopt दिखाता है, तो ऑपरेशन को रैप नहीं किया जाता है. इससे कस्टम शर्तों के आधार पर, चुनिंदा रैपिंग की जा सकती है.

उदाहरण (C++):


stablehlo::CompositeAttributeProviderMap compositeAttributeProviderMap;

compositeAttributeProviderMap[mlir::TypeID::get<mlir::stablehlo::AddOp>()] =
  [](mlir::Operation* op) -> std::optional<mlir::NamedAttrList> {
  // Custom logic to determine if and how to wrap the operation.
  // Example: Only wrap if it's on a specific type.
  if (mlir::isa<mlir::Float32Type>(op->getOperand(0).getType())) {
    return mlir::NamedAttrList(op->getAttrs());
  }
  return std::nullopt; // Do not wrap.
};

pm.addPass(createStablehloWrapInCompositePass(compositeAttributeProviderMap, compositeVersion));
if (mlir::failed(pm.run(module))) {
  return;
}

विकल्प

-op-names : The names of the ops to wrap.
-version  : The version number of the composite op.

-vhlo-legalize-to-stablehlo

VHLO को StableHLO में बदलना.

-vhlo-to-version

वीएचएलओ के अलग-अलग वर्शन के बीच कन्वर्ज़न करके, उन्हें एक-दूसरे के साथ काम करने लायक बनाएं.

यह कुकी, आईआर को अपग्रेड और डाउनग्रेड करने के लिए, वीएचएलओ के वर्शन के बीच कनवर्ट करती है. इससे आगे और पीछे के वर्शन के साथ काम करने की सुविधा बनी रहती है.

"vhlo.exponential_v2"(%[[ARG0]]) <{result_accuracy = DEFAULT}>
# ==( -target=1.0.0 )==>
"vhlo.exponential_v1"(%[[ARG0]])
# ==( -target=1.9.0 )==>
"vhlo.exponential_v2"(%[[ARG0]]) <{result_accuracy = DEFAULT}>

VHLO का इस्तेमाल, आगे और पीछे की ओर कंपैटिबिलिटी बनाए रखने के लिए कैसे किया जाता है, इस बारे में पूरी जानकारी के लिए vhlo.md > The VHLO dialect देखें.

विकल्प

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