OpenXLA Project

इस पेज का अनुवाद Cloud Translation API से किया गया है.

`-chlo-legalize-to-stablehlo`

यह CHLO ऑपरेशन फ़्लो से StableHLO और आकार ops तक कानूनी तौर पर मान्य करता है

`-shape-legalize-to-stablehlo`

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

एक प्रयोग वाला पास जो आकार से जुड़े ऑपरेशन को StableHLO ops को कानूनी तौर पर मंज़ूरी देता है.

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

`-stablehlo-aggressive-folder`

StableHLO की कार्रवाइयों को फ़ोल्ड करता है

विकल्प

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

`-stablehlo-aggressive-simplification`

StableHLO की कार्रवाइयों को कैननिकल के तौर पर मंज़ूरी देता है

`-stablehlo-canonicalize-dynamism`

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

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

उदाहरण के लिए, अगर DynamicReशॉप का आउटपुट_शेप ऑपरेंड कोई स्थिर मान है वैल्यू है, तो ऑपरेशन को ReshapeOp में बदला जा सकता है.

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

कंपोज़िट के सबसेट को इस बदलाव से अलग किया जा सकता है. इसके लिए, "इसके अलावा" फ़्लैग का इस्तेमाल करें, जैसे:

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 डेप्रिकेशन आरएफ़सी (#2283) के तहत, कई अतिरिक्त ऑपरेशन शामिल हैं. इस पास से, इन सेशन के असर का आकलन करने में मदद मिलती है उन्हें अलग-अलग कंपाइलेशन पाइपलाइन में कानूनी रूप से वैध लंबे समय तक इस्तेमाल किए जा सकने वाले वर्शन हो सकते हैं.

विकल्प

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

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

SableHLO की क्वांटाइज़ की गई कार्रवाई में फ़्यूज़ (संख्या में बदलना, फ़्लोटिंग-पॉइंट ऑपरेशन करना, और क्वांटाइज़ करना) पैटर्न

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

UnitQuantized टाइप का इस्तेमाल करने वाले 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`

SableHLO को VHLO से कानूनी बनाना.

`-stablehlo-refine-arguments`

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

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

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 प्रोग्राम में सही स्ट्रक्चर तैयार किया जाता है. इसके बाद, इसके आर्ग्युमेंट टाइप को डाइनैमिक शेप से बदलकर स्टैटिक शेप और इस पास को चलाने से, सभी पर स्टैटिक शेप लागू होंगे प्रोग्राम में शामिल न हो.

`-vhlo-legalize-to-stablehlo`

VHLO को StableHLO से कानूनी तौर पर मान्य करें.

`-vhlo-to-version`

VHLO के एक वर्शन से दूसरे वर्शन पर जाएं.

विकल्प

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