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

'मह्लो' बोली

संचालन

`mhlo.abs` (mhlo::AbsOp)

एब्स ऑपरेशन

वाक्यविन्यास:

operation ::= `mhlo.abs` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

operand टेंसर पर तत्व-वार एब्स ऑपरेशन करता है और result टेंसर उत्पन्न करता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#abs

उदाहरण:

%result = mhlo.abs %operand : tensor<3xi32>

विशेषताएँ: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड विवरण

operand 2/4/8/16/32/64-बिट संकेतरहित पूर्णांक या 4/6/8/16/32/64-बिट फ़्लोट या 32/64-बिट फ़्लोट तत्वों के साथ जटिल प्रकार का रैंक वाला टेंसर या 2/4/8/16/32-बिट एकसमान परिमाणित हस्ताक्षरित पूर्णांक या 2/4/8/16/32-बिट एकसमान परिमाणित प्रति अक्ष हस्ताक्षरित पूर्णांक या 2/4/8/16/32-बिट एकसमान परिमाणित अहस्ताक्षरित पूर्णांक या 2/4/8/16/32-बिट एकसमान परिमाणित प्रति अक्ष अहस्ताक्षरित पूर्णांक मान

ओपेरंड	विवरण
`operand`	2/4/8/16/32/64-बिट संकेतरहित पूर्णांक या 4/6/8/16/32/64-बिट फ़्लोट या 32/64-बिट फ़्लोट तत्वों के साथ जटिल प्रकार का रैंक वाला टेंसर या 2/4/8/16/32-बिट एकसमान परिमाणित हस्ताक्षरित पूर्णांक या 2/4/8/16/32-बिट एकसमान परिमाणित प्रति अक्ष हस्ताक्षरित पूर्णांक या 2/4/8/16/32-बिट एकसमान परिमाणित अहस्ताक्षरित पूर्णांक या 2/4/8/16/32-बिट एकसमान परिमाणित प्रति अक्ष अहस्ताक्षरित पूर्णांक मान

परिणाम:

परिणाम विवरण

result 2/4/8/16/32/64-बिट हस्ताक्षर रहित पूर्णांक या 4/6/8/16/32/64-बिट फ़्लोट या 2/4/8/16/32-बिट समान परिमाणित हस्ताक्षरित पूर्णांक या 2/4/8/16/32-बिट समान परिमाणित प्रति अक्ष हस्ताक्षरित पूर्णांक या 2/4/8/16/32-बिट समान परिमाणित अहस्ताक्षरित पूर्णांक या 2/4/8/16/32-बिट समान परिमाणित प्रति अक्ष अहस्ताक्षरित पूर्णांक मानों का रैंक्ड टेंसर

परिणाम	विवरण
`result`	2/4/8/16/32/64-बिट हस्ताक्षर रहित पूर्णांक या 4/6/8/16/32/64-बिट फ़्लोट या 2/4/8/16/32-बिट समान परिमाणित हस्ताक्षरित पूर्णांक या 2/4/8/16/32-बिट समान परिमाणित प्रति अक्ष हस्ताक्षरित पूर्णांक या 2/4/8/16/32-बिट समान परिमाणित अहस्ताक्षरित पूर्णांक या 2/4/8/16/32-बिट समान परिमाणित प्रति अक्ष अहस्ताक्षरित पूर्णांक मानों का रैंक्ड टेंसर

`mhlo.acos` (mhlo::AcosOp)

Acos ऑपरेशन

वाक्यविन्यास:

operation ::= `mhlo.acos` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

operand टेंसर पर तत्व-वार acos ऑपरेशन करता है और result टेंसर उत्पन्न करता है।

उदाहरण:

%result = mhlo.acos %operand : tensor<2x2xf32>

विशेषताएँ: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

इंटरफेस: InferShapedTypeOpInterface , InferTypeOpInterface

ऑपरेंड:

ओपेरंड	विवरण
`operand`	4/6/8/16/32/64-बिट फ़्लोट या 32/64-बिट फ़्लोट तत्व मानों के साथ जटिल प्रकार का टेंसर

परिणाम:

परिणाम	विवरण
`result`	4/6/8/16/32/64-बिट फ़्लोट या 32/64-बिट फ़्लोट तत्व मानों के साथ जटिल प्रकार का टेंसर

`mhlo.acosh` (mhlo::AcoshOp)

एकोश ऑपरेशन

वाक्यविन्यास:

operation ::= `mhlo.acosh` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

operand टेंसर पर तत्व-वार acosh ऑपरेशन करता है और result टेंसर उत्पन्न करता है।

उदाहरण:

%result = mhlo.acosh %operand : tensor<2x2xf32>

विशेषताएँ: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

इंटरफेस: InferShapedTypeOpInterface , InferTypeOpInterface

ऑपरेंड:

ओपेरंड	विवरण
`operand`	4/6/8/16/32/64-बिट फ़्लोट या 32/64-बिट फ़्लोट तत्व मानों के साथ जटिल प्रकार का टेंसर

परिणाम:

परिणाम	विवरण
`result`	4/6/8/16/32/64-बिट फ़्लोट या 32/64-बिट फ़्लोट तत्व मानों के साथ जटिल प्रकार का टेंसर

`mhlo.add` (mhlo::AddOp)

ऑपरेशन जोड़ें

वाक्यविन्यास:

operation ::= `mhlo.add` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

दो टेंसरों lhs और rhs का तत्ववार जोड़ करता है और एक result टेंसर उत्पन्न करता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#add

उदाहरण:

%result = mhlo.add %lhs, %rhs : tensor<2x2xi32>

लक्षण: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड विवरण

lhs 4/6/8/16/32/64-बिट फ़्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ़्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज़्ड या प्रति-अक्ष पूर्णांक क्वांटाइज़्ड मानों के साथ जटिल प्रकार का रैंक वाला टेंसर

rhs 4/6/8/16/32/64-बिट फ़्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ़्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज़्ड या प्रति-अक्ष पूर्णांक क्वांटाइज़्ड मानों के साथ जटिल प्रकार का रैंक वाला टेंसर

ओपेरंड	विवरण
`lhs`	4/6/8/16/32/64-बिट फ़्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ़्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज़्ड या प्रति-अक्ष पूर्णांक क्वांटाइज़्ड मानों के साथ जटिल प्रकार का रैंक वाला टेंसर
`rhs`	4/6/8/16/32/64-बिट फ़्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ़्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज़्ड या प्रति-अक्ष पूर्णांक क्वांटाइज़्ड मानों के साथ जटिल प्रकार का रैंक वाला टेंसर

परिणाम:

परिणाम विवरण

result 4/6/8/16/32/64-बिट फ़्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ़्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज़्ड या प्रति-अक्ष पूर्णांक क्वांटाइज़्ड मानों के साथ जटिल प्रकार का रैंक वाला टेंसर

परिणाम	विवरण
`result`	4/6/8/16/32/64-बिट फ़्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ़्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज़्ड या प्रति-अक्ष पूर्णांक क्वांटाइज़्ड मानों के साथ जटिल प्रकार का रैंक वाला टेंसर

`mhlo.add_dependency` (mhlo::AddDependencyOp)

निर्भरता जोड़ें ऑपरेशन

वाक्यविन्यास:

operation ::= `mhlo.add_dependency` operands attr-dict `:` functional-type(operands, results)

यह ऑपरेशन XLA कंपाइलर के लिए निजी है, इसलिए इसका अभी तक कोई विनिर्देश नहीं है।

अनौपचारिक रूप से, इस ऑपरेशन में दो ऑपरेंड होते हैं: एक डेटा ऑपरेंड और एक टोकन। इस ऑपरेशन का आउटपुट डेटा ऑपरेंड होता है। AfterAll के साथ उपयोग किए जाने पर, यह ऑपरेशन गैर-साइड-इफेक्टिंग ऑपरेशनों (जो टोकन मान उत्पन्न नहीं करते) को क्रमबद्ध करने में सक्षम बनाता है।

उदाहरण:

%1 = mhlo.add_dependency %arg0, %0 : (tensor<3x4xf32>, !mhlo.token) -> tensor<3x4xf32>

लक्षण: AlwaysSpeculatableImplTrait

इंटरफेस: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड विवरण

operand 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों के साथ जटिल प्रकार या प्रति-टेंसर पूर्णांक क्वांटाइज्ड मान या प्रति-अक्ष पूर्णांक क्वांटाइज्ड मान या टोकन या स्टेबलहो टोकन का रैंक्ड टेंसर

token टोकन या स्टेबलहो टोकन

ओपेरंड	विवरण
`operand`	4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों के साथ जटिल प्रकार या प्रति-टेंसर पूर्णांक क्वांटाइज्ड मान या प्रति-अक्ष पूर्णांक क्वांटाइज्ड मान या टोकन या स्टेबलहो टोकन का रैंक्ड टेंसर
`token`	टोकन या स्टेबलहो टोकन

परिणाम:

परिणाम विवरण

output 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों के साथ जटिल प्रकार या प्रति-टेंसर पूर्णांक क्वांटाइज्ड मान या प्रति-अक्ष पूर्णांक क्वांटाइज्ड मान या टोकन या स्टेबलहो टोकन का रैंक्ड टेंसर

परिणाम	विवरण
`output`	4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों के साथ जटिल प्रकार या प्रति-टेंसर पूर्णांक क्वांटाइज्ड मान या प्रति-अक्ष पूर्णांक क्वांटाइज्ड मान या टोकन या स्टेबलहो टोकन का रैंक्ड टेंसर

`mhlo.after_all` (mhlo::AfterAllOp)

आफ्टरऑल ऑपरेशन

वाक्यविन्यास:

operation ::= `mhlo.after_all` $inputs attr-dict
              `:` custom<VariadicSameOperandsAndResultType>(ref($inputs), type($inputs), type($result))

यह सुनिश्चित करता है कि inputs उत्पन्न करने वाले ऑपरेशन result पर निर्भर किसी भी ऑपरेशन से पहले निष्पादित किए जाते हैं।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#after_all

उदाहरण:

%result = mhlo.after_all %input0, %input1 : !mhlo.token

लक्षण: AlwaysSpeculatableImplTrait

इंटरफेस: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`inputs`	टोकन का वैरिएडिक

परिणाम:

परिणाम	विवरण
`result`	टोकन

`mhlo.all_gather` (mhlo::AllGatherOp)

ऑलगैदर ऑपरेशन

प्रक्रिया ग्रिड में प्रत्येक प्रक्रिया समूह के भीतर, all_gather_dim के साथ प्रत्येक प्रक्रिया से ऑपरेंड टेंसर के मानों को संयोजित करता है और एक परिणाम टेंसर उत्पन्न करता है। operands में प्रत्येक ऑपरेंड के लिए computation अलग से लागू की जाती है, जिससे प्रत्येक ऑपरेंड एक परिणाम उत्पन्न होता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_gather

उदाहरण:

%result = "mhlo.all_gather"(%operand) {
  all_gather_dim = 1 : i64,
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>
  // channel_id = 0
  channel_handle = #mhlo.channel_handle<handle = 0, type = 0>,
  // use_global_device_ids = false
} : (tensor<2x2xf32>) -> tensor<2x4xf32>

लक्षण: SameOperandsAndResultElementType

गुण:

गुण	एमएलआईआर प्रकार	विवरण
`all_gather_dim`	::mlir::IntegerAttr	64-बिट संकेतरहित पूर्णांक विशेषता जिसका मान ऋणात्मक नहीं है
`replica_groups`	::mlir::DenseIntElementsAttr	64-बिट साइनलेस पूर्णांक तत्व विशेषता
`channel_handle`	::mlir::mhlo::ChannelHandleAttr	दो 64-बिट पूर्णांक 'हैंडल' और 'टाइप'
`use_global_device_ids`	::mlir::UnitAttr	इकाई विशेषता

ऑपरेंड:

ओपेरंड विवरण

operands 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज्ड या प्रति-अक्ष पूर्णांक क्वांटाइज्ड मानों के साथ जटिल प्रकार के रैंक्ड टेंसर का वैरिएडिक

ओपेरंड	विवरण
`operands`	4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज्ड या प्रति-अक्ष पूर्णांक क्वांटाइज्ड मानों के साथ जटिल प्रकार के रैंक्ड टेंसर का वैरिएडिक

परिणाम:

परिणाम	विवरण
«अनाम»	4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज्ड या प्रति-अक्ष पूर्णांक क्वांटाइज्ड मानों के साथ जटिल प्रकार के रैंक्ड टेंसर का वैरिएडिक

परिणाम

विवरण

«अनाम»

4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज्ड या प्रति-अक्ष पूर्णांक क्वांटाइज्ड मानों के साथ जटिल प्रकार के रैंक्ड टेंसर का वैरिएडिक

`mhlo.all_reduce` (mhlo::AllReduceOp)

AllReduce ऑपरेशन

प्रक्रिया ग्रिड में प्रत्येक प्रक्रिया समूह के भीतर, प्रत्येक प्रक्रिया से एक ऑपरेंड टेंसर के मानों पर एक रिडक्शन फ़ंक्शन computation लागू करता है और एक परिणाम टेंसर उत्पन्न करता है। यह computation operands में प्रत्येक ऑपरेंड के लिए अलग से लागू किया जाता है, जिससे प्रत्येक ऑपरेंड एक परिणाम उत्पन्न होता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_reduce

उदाहरण:

%result = "mhlo.all_reduce"(%operand) ({
  ^bb0(%arg0: tensor<f32>, %arg1: tensor<f32>):
    %0 = mhlo.add %arg1, %arg2 : tensor<f32>
    mhlo.return %0 : tensor<f32>
}) {
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>
  // channel_id = 0
  channel_handle = #mhlo.channel_handle<handle = 0, type = 0>
  // use_global_device_ids = false
} : (tensor<4xf32>) -> tensor<4xf32>

विशेषताएँ: InferTensorType , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

इंटरफेस: InferShapedTypeOpInterface , InferTypeOpInterface

गुण:

गुण	एमएलआईआर प्रकार	विवरण
`replica_groups`	::mlir::DenseIntElementsAttr	64-बिट साइनलेस पूर्णांक तत्व विशेषता
`channel_handle`	::mlir::mhlo::ChannelHandleAttr	दो 64-बिट पूर्णांक 'हैंडल' और 'टाइप'
`use_global_device_ids`	::mlir::UnitAttr	इकाई विशेषता

ऑपरेंड:

ओपेरंड विवरण

ओपेरंड	विवरण
`operands`	4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज्ड या प्रति-अक्ष पूर्णांक क्वांटाइज्ड मानों के साथ जटिल प्रकार के रैंक्ड टेंसर का वैरिएडिक

परिणाम:

परिणाम	विवरण
«अनाम»	4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज्ड या प्रति-अक्ष पूर्णांक क्वांटाइज्ड मानों के साथ जटिल प्रकार के रैंक्ड टेंसर का वैरिएडिक

परिणाम

विवरण

«अनाम»

`mhlo.all_to_all` (mhlo::AllToAllOp)

AllToAll ऑपरेशन

प्रक्रिया ग्रिड में प्रत्येक प्रक्रिया समूह के भीतर, split_dimension के साथ operand टेंसर के मानों को भागों में विभाजित करता है, विभाजित भागों को प्रक्रियाओं के बीच बिखेरता है, बिखरे हुए भागों को concat_dimension के साथ जोड़ता है और एक result टेंसर उत्पन्न करता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_to_all

उदाहरण:

%result = "mhlo.all_to_all"(%operand) {
  split_dimension = 1 : i64,
  concat_dimension = 0 : i64,
  split_count = 2 : i64,
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>
} : (tensor<2x4xf32>) -> tensor<4x2xf32>

विशेषताएँ: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsElementType , SameOperandsShape , SameVariadicOperandSize

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

गुण:

गुण	एमएलआईआर प्रकार	विवरण
`split_dimension`	::mlir::IntegerAttr	64-बिट संकेतरहित पूर्णांक विशेषता जिसका मान ऋणात्मक नहीं है
`concat_dimension`	::mlir::IntegerAttr	64-बिट संकेतरहित पूर्णांक विशेषता जिसका मान ऋणात्मक नहीं है
`split_count`	::mlir::IntegerAttr	64-बिट संकेतरहित पूर्णांक विशेषता जिसका मान धनात्मक है
`replica_groups`	::mlir::DenseIntElementsAttr	64-बिट साइनलेस पूर्णांक तत्व विशेषता
`channel_handle`	::mlir::mhlo::ChannelHandleAttr	दो 64-बिट पूर्णांक 'हैंडल' और 'टाइप'

ऑपरेंड:

ओपेरंड विवरण

operand 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज्ड या प्रति-अक्ष पूर्णांक क्वांटाइज्ड मानों के साथ जटिल प्रकार के रैंक्ड टेंसर का वैरिएडिक

ओपेरंड	विवरण
`operand`	4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज्ड या प्रति-अक्ष पूर्णांक क्वांटाइज्ड मानों के साथ जटिल प्रकार के रैंक्ड टेंसर का वैरिएडिक

परिणाम:

परिणाम	विवरण
«अनाम»	4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज्ड या प्रति-अक्ष पूर्णांक क्वांटाइज्ड मानों के साथ जटिल प्रकार के रैंक्ड टेंसर का वैरिएडिक

परिणाम

विवरण

«अनाम»

`mhlo.and` (mhlo::AndOp)

और संचालन

वाक्यविन्यास:

operation ::= `mhlo.and` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

दो टेंसर lhs और rhs का तत्व-वार AND करता है और एक result टेंसर उत्पन्न करता है

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#and

उदाहरण:

%result = mhlo.and %lhs, %rhs : tensor<2x2xi32>

लक्षण: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`lhs`	बूल या 2/4/8/16/32/64-बिट पूर्णांक मानों का रैंक्ड टेंसर
`rhs`	बूल या 2/4/8/16/32/64-बिट पूर्णांक मानों का रैंक्ड टेंसर

परिणाम:

परिणाम विवरण

परिणाम	विवरण
`result`	4/6/8/16/32/64-बिट फ़्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ़्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज़्ड या प्रति-अक्ष पूर्णांक क्वांटाइज़्ड मानों के साथ जटिल प्रकार का रैंक वाला टेंसर

`mhlo.asin` (mhlo::AsinOp)

असिन ऑपरेशन

वाक्यविन्यास:

operation ::= `mhlo.asin` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

operand टेंसर पर तत्व-वार एसिन ऑपरेशन करता है और result टेंसर उत्पन्न करता है।

उदाहरण:

%result = mhlo.asin %operand : tensor<2x2xf32>

विशेषताएँ: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

इंटरफेस: InferShapedTypeOpInterface , InferTypeOpInterface

ऑपरेंड:

ओपेरंड	विवरण
`operand`	4/6/8/16/32/64-बिट फ़्लोट या 32/64-बिट फ़्लोट तत्व मानों के साथ जटिल प्रकार का टेंसर

परिणाम:

परिणाम	विवरण
`result`	4/6/8/16/32/64-बिट फ़्लोट या 32/64-बिट फ़्लोट तत्व मानों के साथ जटिल प्रकार का टेंसर

`mhlo.async_done` (mhlo::AsyncDoneOp)

AsyncDone ऑपरेशन

यह ऑपरेशन XLA कंपाइलर के लिए निजी है, इसलिए इसका अभी तक कोई विनिर्देश नहीं है।

अनौपचारिक रूप से, यह ऑपरेशन किसी अतुल्यकालिक गणना के अंत तक अवरुद्ध रहता है। यह अतुल्यकालिक गणना का अंतिम परिणाम लौटाता है।

अधिक जानकारी के लिए AsyncStart का दस्तावेज़ देखें.

इंटरफेस: InferTypeOpInterface

ऑपरेंड:

ओपेरंड विवरण

bundle async_bundle 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज्ड या प्रति-अक्ष पूर्णांक क्वांटाइज्ड मान या टोकन या स्टेबलएचएलओ टोकन मानों के साथ जटिल प्रकार के रैंक्ड टेंसर के किसी भी संयोजन के साथ

ओपेरंड	विवरण
`bundle`	async_bundle 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज्ड या प्रति-अक्ष पूर्णांक क्वांटाइज्ड मान या टोकन या स्टेबलएचएलओ टोकन मानों के साथ जटिल प्रकार के रैंक्ड टेंसर के किसी भी संयोजन के साथ

परिणाम:

परिणाम	विवरण
«अनाम»	4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या जटिल प्रकार के रैंक वाले टेंसर के वैरिएडिक 32/64-बिट फ्लोट तत्वों के साथ या प्रति-टेंसर पूर्णांक क्वांटाइज्ड या प्रति-अक्ष पूर्णांक क्वांटाइज्ड मान या टोकन या स्टेबलहो टोकन या नेस्टेड टपल 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या जटिल प्रकार के रैंक वाले टेंसर के किसी भी संयोजन के साथ 32/64-बिट फ्लोट तत्वों के साथ या प्रति-टेंसर पूर्णांक क्वांटाइज्ड मान या 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या जटिल प्रकार के मेमरेफ प्रति-अक्ष पूर्णांक परिमाणित मान या टोकन मान

परिणाम

विवरण

«अनाम»

4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या जटिल प्रकार के रैंक वाले टेंसर के वैरिएडिक 32/64-बिट फ्लोट तत्वों के साथ या प्रति-टेंसर पूर्णांक क्वांटाइज्ड या प्रति-अक्ष पूर्णांक क्वांटाइज्ड मान या टोकन या स्टेबलहो टोकन या नेस्टेड टपल 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या जटिल प्रकार के रैंक वाले टेंसर के किसी भी संयोजन के साथ 32/64-बिट फ्लोट तत्वों के साथ या प्रति-टेंसर पूर्णांक क्वांटाइज्ड मान या 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या जटिल प्रकार के मेमरेफ प्रति-अक्ष पूर्णांक परिमाणित मान या टोकन मान

`mhlo.async_start` (mhlo::AsyncStartOp)

AsyncStart ऑपरेशन

यह ऑपरेशन XLA कंपाइलर के लिए निजी है, इसलिए इसका अभी तक कोई विनिर्देश नहीं है।

अनौपचारिक रूप से, यह ऑपरेशन एक अतुल्यकालिक गणना को प्रारंभ करता है।

इसका उपयोग तब किया जाता है जब ऐसे फ़ंक्शन होते हैं जिनमें एसिंक्रोनस प्रतीक्षा (जैसे DMA) और ऑन-थ्रेड गणना दोनों शामिल होती हैं। उदाहरण के लिए, एक फ़ंक्शन में एक गणना, एक DMA, एक अन्य गणना, एक दूसरा DMA और एक अंतिम गणना शामिल हो सकती है। इसे async_start के रूप में दर्शाया जाएगा, उसके बाद async_update और एक async_done होगा। async_start पहली गणना ऑन-थ्रेड करेगा और फिर DMA शुरू करेगा। async_update, यदि DMA अभी तक पूरा नहीं हुआ है, तो उसके पूरा होने की प्रतीक्षा करेगा, फिर फ़ंक्शन में दूसरी गणना निष्पादित करेगा और दूसरा DMA शुरू करेगा। अंत में, async_done इस अंतिम DMA पर प्रतीक्षा करेगा, और फिर अंतिम गणना चलाएगा जिसे ऑन-थ्रेड चलाने की आवश्यकता है और उस अंतिम गणना का परिणाम लौटाएगा।

operands सीधे कंप्यूटेशन में पास किए जाते हैं called_computation वह फ़ंक्शन है जो एसिंक्रोनस रूप से चलाया जाएगा। execution_thread उस थ्रेड का नाम है जिसमें इसे चलाया जाएगा। मुख्य थ्रेड को "main" कहा जाता है। सभी थ्रेड्स के नाम होते हैं।

यह एसिंक्रोनस ऑप्स के बीच आवश्यक सभी स्थितियाँ लौटाता है। बफ़र असाइनमेंट के बाद, वापसी मान इनपुट, परिणामों और एसिंक्रोनस ऑप्स द्वारा आवश्यक या संपादित किए गए किसी भी स्क्रैचपैड को रखने के लिए आवश्यक स्थान को दर्शाता है।

गुण:

गुण	एमएलआईआर प्रकार	विवरण
`called_computation`	::mlir::FlatSymbolRefAttr	फ्लैट प्रतीक संदर्भ विशेषता
`execution_thread`	::mlir::StringAttr	स्ट्रिंग विशेषता

ऑपरेंड:

ओपेरंड विवरण

inputs 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या जटिल प्रकार के रैंक वाले टेंसर के वैरिएडिक 32/64-बिट फ्लोट तत्वों के साथ या प्रति-टेंसर पूर्णांक क्वांटाइज्ड या प्रति-अक्ष पूर्णांक क्वांटाइज्ड मान या टोकन या स्टेबलहो टोकन या नेस्टेड टपल 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या जटिल प्रकार के रैंक वाले टेंसर के किसी भी संयोजन के साथ 32/64-बिट फ्लोट तत्वों के साथ या प्रति-टेंसर पूर्णांक क्वांटाइज्ड मान या 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या जटिल प्रकार के मेमरेफ प्रति-अक्ष पूर्णांक परिमाणित मान या टोकन मान

ओपेरंड	विवरण
`inputs`	4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या जटिल प्रकार के रैंक वाले टेंसर के वैरिएडिक 32/64-बिट फ्लोट तत्वों के साथ या प्रति-टेंसर पूर्णांक क्वांटाइज्ड या प्रति-अक्ष पूर्णांक क्वांटाइज्ड मान या टोकन या स्टेबलहो टोकन या नेस्टेड टपल 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या जटिल प्रकार के रैंक वाले टेंसर के किसी भी संयोजन के साथ 32/64-बिट फ्लोट तत्वों के साथ या प्रति-टेंसर पूर्णांक क्वांटाइज्ड मान या 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या जटिल प्रकार के मेमरेफ प्रति-अक्ष पूर्णांक परिमाणित मान या टोकन मान

परिणाम:

परिणाम	विवरण
«अनाम»	async_bundle 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज्ड या प्रति-अक्ष पूर्णांक क्वांटाइज्ड मान या टोकन या स्टेबलएचएलओ टोकन मानों के साथ जटिल प्रकार के रैंक्ड टेंसर के किसी भी संयोजन के साथ

परिणाम

विवरण

«अनाम»

async_bundle 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज्ड या प्रति-अक्ष पूर्णांक क्वांटाइज्ड मान या टोकन या स्टेबलएचएलओ टोकन मानों के साथ जटिल प्रकार के रैंक्ड टेंसर के किसी भी संयोजन के साथ

`mhlo.async_update` (mhlo::AsyncUpdateOp)

AsyncUpdate ऑपरेशन

यह ऑपरेशन XLA कंपाइलर के लिए निजी है, इसलिए इसका अभी तक कोई विनिर्देश नहीं है।

अनौपचारिक रूप से, यह ऑपरेशन किसी सिंक्रोनस कंप्यूटेशन को सिंक बैरियर तक ब्लॉक कर देता है। यह उस पर काम करने के बाद bundle लौटाता है।

अधिक जानकारी के लिए AsyncStart का दस्तावेज़ देखें.

इंटरफेस: InferTypeOpInterface

ऑपरेंड:

ओपेरंड विवरण

ओपेरंड	विवरण
`bundle`	async_bundle 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज्ड या प्रति-अक्ष पूर्णांक क्वांटाइज्ड मान या टोकन या स्टेबलएचएलओ टोकन मानों के साथ जटिल प्रकार के रैंक्ड टेंसर के किसी भी संयोजन के साथ

परिणाम:

परिणाम	विवरण
«अनाम»	async_bundle 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज्ड या प्रति-अक्ष पूर्णांक क्वांटाइज्ड मान या टोकन या स्टेबलएचएलओ टोकन मानों के साथ जटिल प्रकार के रैंक्ड टेंसर के किसी भी संयोजन के साथ

परिणाम

विवरण

«अनाम»

`mhlo.atan2` (mhlo::Atan2Op)

Atan2 ऑपरेशन

वाक्यविन्यास:

operation ::= `mhlo.atan2` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

lhs और rhs टेंसर पर तत्व-वार एटन2 ऑपरेशन करता है और result टेंसर उत्पन्न करता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#atan2

उदाहरण:

%result = mhlo.atan2 %lhs, %rhs : tensor<3xf32>

विशेषताएँ: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`lhs`	4/6/8/16/32/64-बिट फ्लोट या जटिल प्रकार के रैंक किए गए टेंसर, 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज्ड मानों के साथ
`rhs`	4/6/8/16/32/64-बिट फ्लोट या जटिल प्रकार के रैंक किए गए टेंसर, 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज्ड मानों के साथ

परिणाम:

परिणाम	विवरण
`result`	4/6/8/16/32/64-बिट फ्लोट या जटिल प्रकार के रैंक किए गए टेंसर, 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज्ड मानों के साथ

`mhlo.atanh` (mhlo::AtanhOp)

अतन्ह ऑपरेशन

वाक्यविन्यास:

operation ::= `mhlo.atanh` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

operand टेंसर पर तत्व-वार atanh ऑपरेशन करता है और result टेंसर उत्पन्न करता है।

उदाहरण:

%result = mhlo.atanh %operand : tensor<2x2xf32>

विशेषताएँ: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

इंटरफेस: InferShapedTypeOpInterface , InferTypeOpInterface

ऑपरेंड:

ओपेरंड	विवरण
`operand`	4/6/8/16/32/64-बिट फ़्लोट या 32/64-बिट फ़्लोट तत्व मानों के साथ जटिल प्रकार का टेंसर

परिणाम:

परिणाम	विवरण
`result`	4/6/8/16/32/64-बिट फ़्लोट या 32/64-बिट फ़्लोट तत्व मानों के साथ जटिल प्रकार का टेंसर

`mhlo.batch_norm_grad` (mhlo::BatchNormGradOp)

बैचनॉर्मग्रेड ऑपरेशन

grad_output से बैकप्रोपेगेटिंग BatchNormTrainingOp के कई इनपुट के ग्रेडिएंट की गणना करता है, और grad_operand , grad_scale और grad_offset टेंसर का उत्पादन करता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_grad

उदाहरण:

%grad_operand, %grad_scale, %grad_offset =
"mhlo.batch_norm_grad"(%operand, %scale, %mean, %variance, %grad_output) {
  epsilon = 0.0 : f32,
  feature_index = 2 : i64
} : (tensor<2x2x2xf32>, tensor<2xf32>, tensor<2xf32>, tensor<2xf32>,
    tensor<2x2x2xf32>) -> (tensor<2x2x2xf32>, tensor<2xf32>, tensor<2xf32>)

लक्षण: AlwaysSpeculatableImplTrait , InferTensorType

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

गुण:

गुण	एमएलआईआर प्रकार	विवरण
`epsilon`	::mlir::FloatAttr	32-बिट फ्लोट विशेषता
`feature_index`	::mlir::IntegerAttr	64-बिट संकेतरहित पूर्णांक विशेषता जिसका मान ऋणात्मक नहीं है

ऑपरेंड:

ओपेरंड	विवरण
`operand`	4/6/8/16/32/64-बिट फ़्लोट मानों का रैंक्ड टेंसर
`scale`	4/6/8/16/32/64-बिट फ़्लोट मानों का 1D टेंसर
`mean`	4/6/8/16/32/64-बिट फ़्लोट मानों का 1D टेंसर
`variance`	4/6/8/16/32/64-बिट फ़्लोट मानों का 1D टेंसर
`grad_output`	4/6/8/16/32/64-बिट फ़्लोट मानों का रैंक्ड टेंसर

परिणाम:

परिणाम	विवरण
`grad_operand`	4/6/8/16/32/64-बिट फ़्लोट मानों का रैंक्ड टेंसर
`grad_scale`	4/6/8/16/32/64-बिट फ़्लोट मानों का 1D टेंसर
`grad_offset`	4/6/8/16/32/64-बिट फ़्लोट मानों का 1D टेंसर

`mhlo.batch_norm_inference` (mhlo::BatchNormInferenceOp)

बैचनॉर्मइन्फरेंस ऑपरेशन

feature_index आयाम को छोड़कर सभी आयामों में operand टेंसर को सामान्यीकृत करता है और result टेंसर उत्पन्न करता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_inference

उदाहरण:

%result = "mhlo.batch_norm_inference"(%operand, %scale, %offset, %mean, %variance) {
  epsilon = 0.0 : f32,
  feature_index = 2 : i64
} : (tensor<2x2x2xf32>, tensor<2xf32>, tensor<2xf32>, tensor<2xf32>, tensor<2xf32>) -> tensor<2x2x2xf32>

लक्षण: AlwaysSpeculatableImplTrait , InferTensorType

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

गुण:

गुण	एमएलआईआर प्रकार	विवरण
`epsilon`	::mlir::FloatAttr	32-बिट फ्लोट विशेषता
`feature_index`	::mlir::IntegerAttr	64-बिट संकेतरहित पूर्णांक विशेषता जिसका मान ऋणात्मक नहीं है

ऑपरेंड:

ओपेरंड	विवरण
`operand`	4/6/8/16/32/64-बिट फ़्लोट मानों का रैंक्ड टेंसर
`scale`	4/6/8/16/32/64-बिट फ़्लोट मानों का 1D टेंसर
`offset`	4/6/8/16/32/64-बिट फ़्लोट मानों का 1D टेंसर
`mean`	4/6/8/16/32/64-बिट फ़्लोट मानों का 1D टेंसर
`variance`	4/6/8/16/32/64-बिट फ़्लोट मानों का 1D टेंसर

परिणाम:

परिणाम	विवरण
`result`	4/6/8/16/32/64-बिट फ़्लोट मानों का रैंक्ड टेंसर

`mhlo.batch_norm_training` (mhlo::BatchNormTrainingOp)

बैचनॉर्मट्रेनिंग ऑपरेशन

बैच और स्थानिक आयामों में माध्य और विचरण की गणना करता है और feature_index आयाम में प्रत्येक विशेषता के लिए operand टेंसर को सामान्यीकृत करता है और output , batch_mean और batch_var टेंसर उत्पन्न करता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_training

उदाहरण:

%output, %batch_mean, %batch_var = "mhlo.batch_norm_training"(%operand, %scale, %offset) {
  epsilon = 0.0 : f32,
  feature_index = 2 : i64
} : (tensor<2x2x2xf32>, tensor<2xf32>, tensor<2xf32>) -> (tensor<2x2x2xf32>, tensor<2xf32>, tensor<2xf32>)

लक्षण: AlwaysSpeculatableImplTrait , InferTensorType

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

गुण:

गुण	एमएलआईआर प्रकार	विवरण
`epsilon`	::mlir::FloatAttr	32-बिट फ्लोट विशेषता
`feature_index`	::mlir::IntegerAttr	64-बिट संकेतरहित पूर्णांक विशेषता जिसका मान ऋणात्मक नहीं है

ऑपरेंड:

ओपेरंड	विवरण
`operand`	4/6/8/16/32/64-बिट फ़्लोट मानों का रैंक्ड टेंसर
`scale`	4/6/8/16/32/64-बिट फ़्लोट मानों का 1D टेंसर
`offset`	4/6/8/16/32/64-बिट फ़्लोट मानों का 1D टेंसर

परिणाम:

परिणाम	विवरण
`output`	4/6/8/16/32/64-बिट फ़्लोट मानों का रैंक्ड टेंसर
`batch_mean`	4/6/8/16/32/64-बिट फ़्लोट मानों का 1D टेंसर
`batch_var`	4/6/8/16/32/64-बिट फ़्लोट मानों का 1D टेंसर

`mhlo.bitcast` (mhlo::BitcastOp)

बिटकास्ट संचालन

वाक्यविन्यास:

operation ::= `mhlo.bitcast` operands attr-dict `:` functional-type(operands, results)

यह ऑपरेशन XLA कंपाइलर के लिए निजी है, इसलिए इसका अभी तक कोई विनिर्देश नहीं है।

अनौपचारिक रूप से, यह ऑपरेशन इनपुट के आकार को इस तरह बदल देता है कि तत्वों की भौतिक व्यवस्था अपरिवर्तित रहती है।

इस ऑपरेशन को "तत्वों की भौतिक व्यवस्था" को समझने के लिए लेआउट जानकारी की आवश्यकता होती है, और MHLO में लेआउट समर्थन वर्तमान में प्रगति पर है।

उदाहरण:

%0 = mhlo.bitcast %arg0 : (tensor<3x4xf32>) -> tensor<3x4x1xf32>

लक्षण: AlwaysSpeculatableImplTrait

इंटरफेस: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड विवरण

operand 4/6/8/16/32/64-बिट फ़्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ़्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज़्ड या प्रति-अक्ष पूर्णांक क्वांटाइज़्ड मानों के साथ जटिल प्रकार का रैंक वाला टेंसर

ओपेरंड	विवरण
`operand`	4/6/8/16/32/64-बिट फ़्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ़्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज़्ड या प्रति-अक्ष पूर्णांक क्वांटाइज़्ड मानों के साथ जटिल प्रकार का रैंक वाला टेंसर

परिणाम:

परिणाम	विवरण
«अनाम»	4/6/8/16/32/64-बिट फ़्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ़्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज़्ड या प्रति-अक्ष पूर्णांक क्वांटाइज़्ड मानों के साथ जटिल प्रकार का रैंक वाला टेंसर

परिणाम

विवरण

«अनाम»

4/6/8/16/32/64-बिट फ़्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ़्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज़्ड या प्रति-अक्ष पूर्णांक क्वांटाइज़्ड मानों के साथ जटिल प्रकार का रैंक वाला टेंसर

`mhlo.bitcast_convert` (mhlo::BitcastConvertOp)

बिटकास्टकन्वर्ट ऑपरेशन

वाक्यविन्यास:

operation ::= `mhlo.bitcast_convert` operands attr-dict `:` functional-type(operands, results)

operand टेंसर पर बिटकास्ट ऑपरेशन निष्पादित करता है और एक result टेंसर उत्पन्न करता है, जहां संपूर्ण operand टेंसर के बिट्स को result टेंसर के प्रकार का उपयोग करके पुनः व्याख्यायित किया जाता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#bitcast_convert

उदाहरण:

%result = mhlo.bitcast_convert %operand : (tensor<2xf32>) -> tensor<2x4xi8>

लक्षण: AlwaysSpeculatableImplTrait

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड विवरण

ओपेरंड	विवरण
`operand`	4/6/8/16/32/64-बिट फ़्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ़्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज़्ड या प्रति-अक्ष पूर्णांक क्वांटाइज़्ड मानों के साथ जटिल प्रकार का रैंक वाला टेंसर

परिणाम:

परिणाम	विवरण
«अनाम»	4/6/8/16/32/64-बिट फ़्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ़्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज़्ड या प्रति-अक्ष पूर्णांक क्वांटाइज़्ड मानों के साथ जटिल प्रकार का रैंक वाला टेंसर

परिणाम

विवरण

«अनाम»

`mhlo.broadcast` प्रसारण (mhlo::BroadcastOp)

प्रसारण संचालन

यह ऑपरेशन StableHLO से बाहर जाने वाला है, इसलिए इसे विनिर्देश में शामिल नहीं किया गया है: https://github.com/openxla/stablehlo/issues/3

अनौपचारिक रूप से, यह ऑपरेशन XLA के प्रसारण जैसा ही काम करता है: https://www.tensorflow.org/xla/operation_semantics#broadcast

उदाहरण:

%result = mhlo.broadcast %operand, sizes = [1, 2] : (tensor<3xi32>) -> tensor<1x2x3xi32>

विशेषताएँ: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

गुण:

गुण	एमएलआईआर प्रकार	विवरण
`broadcast_sizes`	::mlir::DenseIntElementsAttr	64-बिट साइनलेस पूर्णांक तत्व विशेषता

ऑपरेंड:

ओपेरंड विवरण

परिणाम:

परिणाम

विवरण

«अनाम»

`mhlo.broadcast_in_dim` (mhlo::BroadcastInDimOp)

ब्रॉडकास्टइनडिम ऑपरेशन

operand टेंसर में डेटा की प्रतिलिपि बनाकर इनपुट टेंसर के आयाम और/या रैंक का विस्तार करता है और result टेंसर उत्पन्न करता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#broadcast_in_dim

उदाहरण:

%result = mhlo.broadcast_in_dim %operand, dims = [2, 1] : (tensor<1x3xi32>) -> tensor<2x3x2xi32>

विशेषताएँ: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

इंटरफेस: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

गुण:

गुण	एमएलआईआर प्रकार	विवरण
`broadcast_dimensions`	::mlir::DenseIntElementsAttr	64-बिट साइनलेस पूर्णांक तत्व विशेषता

ऑपरेंड:

ओपेरंड विवरण

परिणाम:

परिणाम

विवरण

«अनाम»

4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज्ड या प्रति-अक्ष पूर्णांक क्वांटाइज्ड मानों के साथ जटिल प्रकार का स्थिर आकार या एकल परिबद्ध आयाम टेंसर

`mhlo.case` (mhlo::CaseOp)

केस ऑपरेशन

index के मान के आधार पर branches से ठीक एक function निष्पादित करने से आउटपुट उत्पन्न करता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#case

उदाहरण:

%result0, %result1 = "mhlo.case"(%index) ({
  mhlo.return %result_branch0, %result_branch0 : tensor<2xi64>, tensor<2xi64>
}, {
  mhlo.return %result_branch1, %result_branch1 : tensor<2xi64>, tensor<2xi64>
}) : (tensor<i32>) -> (tensor<2xi64>, tensor<2xi64>)

विशेषताएँ: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

इंटरफेस: InferTypeOpInterface

ऑपरेंड:

ओपेरंड	विवरण
`index`	32-बिट संकेतरहित पूर्णांक मानों का टेंसर

परिणाम:

परिणाम

विवरण

«अनाम»

4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज्ड मानों या प्रति-अक्ष पूर्णांक क्वांटाइज्ड मानों या टोकन के रैंक्ड टेंसर के साथ जटिल प्रकार के रैंक्ड टेंसर का वैरिएडिक

`mhlo.cbrt` (mhlo::CbrtOp)

सीबीआरटी संचालन

वाक्यविन्यास:

operation ::= `mhlo.cbrt` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

operand टेंसर पर तत्व-वार घनमूल ऑपरेशन करता है और result टेंसर उत्पन्न करता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#cbrt

उदाहरण:

%result = mhlo.cbrt %operand : tensor<4xf32>

विशेषताएँ: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

गुण:

गुण	एमएलआईआर प्रकार	विवरण
`result_accuracy`	::mlir::mhlo::ResultAccuracyAttr	एकल ऑप्स के लिए अनुरोधित सटीकता.

ऑपरेंड:

ओपेरंड	विवरण
`operand`	4/6/8/16/32/64-बिट फ्लोट या जटिल प्रकार के रैंक किए गए टेंसर, 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज्ड मानों के साथ

परिणाम:

परिणाम	विवरण
`result`	4/6/8/16/32/64-बिट फ्लोट या जटिल प्रकार के रैंक किए गए टेंसर, 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज्ड मानों के साथ

`mhlo.ceil` (mhlo::CeilOp)

छत संचालन

वाक्यविन्यास:

operation ::= `mhlo.ceil` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

operand टेंसर की तत्व-वार सीलिंग करता है और result टेंसर उत्पन्न करता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#ceil

उदाहरण:

%result = mhlo.ceil %operand : tensor<5xf32>

विशेषताएँ: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`operand`	4/6/8/16/32/64-बिट फ़्लोट या प्रति-टेंसर पूर्णांक क्वांटाइज़्ड मानों का रैंक्ड टेंसर

परिणाम:

परिणाम	विवरण
`result`	4/6/8/16/32/64-बिट फ़्लोट या प्रति-टेंसर पूर्णांक क्वांटाइज़्ड मानों का रैंक्ड टेंसर

`mhlo.cholesky` (mhlo::ColeskyOp)

कोलेस्की ऑपरेशन

मैट्रिसेस के एक बैच के कोलेस्की अपघटन की गणना करता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#cholesky

उदाहरण:

%result = mhlo.cholesky %a, lower = true : tensor<3x3xf32>

विशेषताएँ: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

गुण:

गुण	एमएलआईआर प्रकार	विवरण
`lower`	::mlir::BoolAttr	बूल विशेषता

ऑपरेंड:

ओपेरंड	विवरण
`a`	4/6/8/16/32/64-बिट फ्लोट या 32/64-बिट फ्लोट तत्व मानों के साथ जटिल प्रकार का रैंक्ड टेंसर

परिणाम:

परिणाम	विवरण
«अनाम»	4/6/8/16/32/64-बिट फ्लोट या 32/64-बिट फ्लोट तत्व मानों के साथ जटिल प्रकार का रैंक्ड टेंसर

`mhlo.clamp` (mhlo::ClampOp)

क्लैंप संचालन

वाक्यविन्यास:

operation ::= `mhlo.clamp` $min `,` $operand `,` $max attr-dict
              `:` custom<SameOperandsAndResultType>(type($min), type($operand), type($max), type($result))

operand टेंसर के प्रत्येक तत्व को न्यूनतम और अधिकतम मान के बीच क्लैंप करता है और result टेंसर उत्पन्न करता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#clamp

उदाहरण:

%result = mhlo.clamp %min, %operand, %max : tensor<3xi32>

विशेषताएँ: AlwaysSpeculatableImplTrait , HLO_BroadcastingElementwise , InferTensorType , SameOperandsAndResultElementType

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`min`	4/6/8/16/32/64-बिट फ़्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ़्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज़्ड या प्रति-अक्ष पूर्णांक क्वांटाइज़्ड मानों के साथ जटिल प्रकार का रैंक वाला टेंसर
`operand`	4/6/8/16/32/64-बिट फ़्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ़्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज़्ड या प्रति-अक्ष पूर्णांक क्वांटाइज़्ड मानों के साथ जटिल प्रकार का रैंक वाला टेंसर
`max`	4/6/8/16/32/64-बिट फ़्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ़्लोट तत्वों या प्रति-टेंसर पूर्णांक क्वांटाइज़्ड या प्रति-अक्ष पूर्णांक क्वांटाइज़्ड मानों के साथ जटिल प्रकार का रैंक वाला टेंसर

परिणाम:

परिणाम विवरण

`mhlo.collective_broadcast` (mhlo::CollectiveBroadcastOp)

सामूहिक प्रसारण संचालन

प्रक्रिया ग्रिड में प्रत्येक प्रक्रिया समूह के भीतर, स्रोत प्रक्रिया से operand टेंसर का मान लक्ष्य प्रक्रियाओं तक भेजें और result टेंसर उत्पन्न करें।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#collective_broadcast

उदाहरण:

%result = "mhlo.collective_broadcast"(%operand) {
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>,
  channel_handle = #mhlo.channel_handle<handle = 0, type = 0>
} : (tensor<1x2xi64>) -> tensor<1x2xi64>

विशेषताएँ: CompatibleOperandsAndResultType

इंटरफेस: InferShapedTypeOpInterface , InferTypeOpInterface

गुण:

गुण	एमएलआईआर प्रकार	विवरण
`replica_groups`	::mlir::DenseIntElementsAttr	64-बिट साइनलेस पूर्णांक तत्व विशेषता
`channel_handle`	::mlir::mhlo::ChannelHandleAttr	दो 64-बिट पूर्णांक 'हैंडल' और 'टाइप'

ऑपरेंड:

ओपेरंड विवरण

परिणाम:

परिणाम

विवरण

«अनाम»

`mhlo.collective_permute` (mhlo::CollectivePermuteOp)

सामूहिक क्रमपरिवर्तन ऑपरेशन

प्रक्रिया ग्रिड में प्रत्येक प्रक्रिया समूह के भीतर, स्रोत प्रक्रिया से लक्ष्य प्रक्रिया तक operand टेंसर का मान भेजता है और result टेंसर उत्पन्न करता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#collective_permute

उदाहरण:

%result = "mhlo.collective_permute"(%operand) {
  source_target_pairs = dense<[[0, 1], [1, 2]]> : tensor<2x2xi64>,
  // channel_id = 0
  channel_handle = #mhlo.channel_handle<handle = 0, type = 0>
} : (tensor<4x2xf32>) -> tensor<4x2xf32>

विशेषताएँ: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

गुण:

गुण	एमएलआईआर प्रकार	विवरण
`source_target_pairs`	::mlir::DenseIntElementsAttr	64-बिट साइनलेस पूर्णांक तत्व विशेषता
`channel_handle`	::mlir::mhlo::ChannelHandleAttr	दो 64-बिट पूर्णांक 'हैंडल' और 'टाइप'

ऑपरेंड:

ओपेरंड विवरण

परिणाम:

परिणाम

विवरण

«अनाम»

`mhlo.compare` (mhlo::CompareOp)

ऑपरेशन की तुलना करें

वाक्यविन्यास:

operation ::= `mhlo.compare` $comparison_direction `,` $lhs `,` $rhs (`,` $compare_type^)?
              attr-dict `:` functional-type(operands, results)

comparison_direction और compare_type के अनुसार lhs और rhs टेंसर की तत्व-वार तुलना करता है, और एक result टेंसर उत्पन्न करता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#compare

उदाहरण:

%result = mhlo.compare LT, %lhs, %rhs, FLOAT : (tensor<2xf32>, tensor<2xf32>) -> tensor<2xi1>

विशेषताएँ: AlwaysSpeculatableImplTrait , Elementwise , InferTensorType , SameOperandsAndResultShape , SameOperandsElementType

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

गुण:

गुण	एमएलआईआर प्रकार	विवरण
`comparison_direction`	::mlir::mhlo::तुलनादिशाAttr	कौन सा तुलना ऑपरेशन करना है.
`compare_type`	::mlir::mhlo::ComparisonTypeAttr	किस तुलना प्रकार का उपयोग करें.

ऑपरेंड:

ओपेरंड विवरण

परिणाम:

परिणाम	विवरण
«अनाम»	बूल मानों का रैंक्ड टेंसर

`mhlo.complex` (mhlo::ComplexOp)

जटिल ऑपरेशन

वाक्यविन्यास:

operation ::= `mhlo.complex` operands attr-dict
              `:` custom<ComplexOpType>(type($lhs), type($rhs), type($result))

वास्तविक और काल्पनिक मानों, lhs और rhs की एक जोड़ी से एक जटिल मान में तत्व-वार रूपांतरण करता है, और एक result टेंसर उत्पन्न करता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#complex

उदाहरण:

%result = mhlo.complex %lhs, %rhs : tensor<2xcomplex<f32>>

विशेषताएँ: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape , SameOperandsElementType

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`lhs`	32/64-बिट फ्लोट मानों का रैंक्ड टेंसर
`rhs`	32/64-बिट फ्लोट मानों का रैंक्ड टेंसर

परिणाम:

परिणाम	विवरण
`result`	32/64-बिट फ्लोट तत्व मानों के साथ जटिल प्रकार का रैंक्ड टेंसर

`mhlo.composite` (mhlo::CompositeOp)

समग्र संचालन

वाक्यविन्यास:

operation ::= `mhlo.composite` $name $inputs attr-dict `:` functional-type(operands, results)

अन्य StableHLO संक्रियाओं से बने (संयोजित) एक संक्रिया को समाहित करता है, inputs और composite_attributes लेकर results उत्पन्न करता है। संक्रिया के अर्थविज्ञान को decomposition विशेषता द्वारा कार्यान्वित किया जाता है। composite संक्रिया को प्रोग्राम अर्थविज्ञान में परिवर्तन किए बिना उसके अपघटन से प्रतिस्थापित किया जा सकता है। ऐसे मामलों में जहाँ अपघटन को इनलाइन करने से समान संक्रिया अर्थविज्ञान प्राप्त नहीं होता, custom_call उपयोग करना बेहतर होगा।

version फ़ील्ड (डिफ़ॉल्ट 0 ) का उपयोग यह दर्शाने के लिए किया जाता है कि किसी कंपोजिट का अर्थविज्ञान कब बदलता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#composite

उदाहरण:

%results = mhlo.composite "my.op" %arg0, %arg1 {
  decomposition = @my_op,
  composite_attributes = { my_attribute = "my_value" },
  version = 1 : i32
} : (tensor<f32>, tensor<f32>) -> tensor<f32>

इंटरफ़ेस: SymbolUserOpInterface

गुण:

गुण	एमएलआईआर प्रकार	विवरण
`name`	::mlir::StringAttr	स्ट्रिंग विशेषता
`composite_attributes`	::mlir::DictionaryAttr	नामित विशेषता मानों का शब्दकोश
`decomposition`	::mlir::FlatSymbolRefAttr	फ्लैट प्रतीक संदर्भ विशेषता
`version`	::mlir::IntegerAttr	32-बिट साइनलेस पूर्णांक विशेषता

ऑपरेंड:

ओपेरंड विवरण

inputs 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों के साथ जटिल प्रकार या प्रति-टेंसर पूर्णांक परिमाणित या प्रति-अक्ष पूर्णांक परिमाणित मान या टोकन या नेस्टेड टपल के रैंक किए गए टेंसर के किसी भी संयोजन के साथ रैंक किए गए टेंसर का विविधता 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या जटिल प्रकार 32/64-बिट फ्लोट तत्वों के साथ या प्रति-टेंसर पूर्णांक परिमाणित मान या 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या जटिल प्रकार का मेमरेफ 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक परिमाणित मानों या प्रति-अक्ष पूर्णांक के रैंक किए गए टेन्सर के साथ परिमाणित मान या टोकन मान

परिणाम:

परिणाम

विवरण

«अनाम»

4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों के साथ जटिल प्रकार या प्रति-टेंसर पूर्णांक परिमाणित या प्रति-अक्ष पूर्णांक परिमाणित मान या टोकन या नेस्टेड टपल के रैंक किए गए टेंसर के किसी भी संयोजन के साथ रैंक किए गए टेंसर का विविधता 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या जटिल प्रकार 32/64-बिट फ्लोट तत्वों के साथ या प्रति-टेंसर पूर्णांक परिमाणित मान या 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या जटिल प्रकार का मेमरेफ 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक परिमाणित मानों या प्रति-अक्ष पूर्णांक के रैंक किए गए टेन्सर के साथ परिमाणित मान या टोकन मान

`mhlo.concatenate` (एमएचएलओ::कॉन्सेटेनेटऑप)

कॉनकैटनेट ऑपरेशन

दिए गए तर्कों के समान क्रम में dimension आयाम के साथ inputs में टेंसरों की एक विविध संख्या को जोड़ता है और एक result टेंसर उत्पन्न करता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#conateate

उदाहरण:

%result = mhlo.concatenate %input0, %input1, dim = 0 : (tensor<3x2xi64>, tensor<1x2xi64>) -> tensor<4x2xi64>

लक्षण: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

गुण:

गुण	एमएलआईआर प्रकार	विवरण
`dimension`	::mlir::IntegerAttr	64-बिट साइनलेस पूर्णांक विशेषता जिसका मान गैर-नकारात्मक है

ऑपरेंड:

ओपेरंड विवरण

val 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक परिमाणित या प्रति-अक्ष पूर्णांक परिमाणित मानों के साथ जटिल प्रकार के रैंक किए गए टेंसर का विविधता

परिणाम:

परिणाम

विवरण

«अनाम»

4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक परिमाणित या प्रति-अक्ष पूर्णांक परिमाणित मानों के साथ जटिल प्रकार का रैंक किया गया टेंसर

`mhlo.constant` (mhlo::ConstantOp)

लगातार संचालन

एक स्थिर value से एक output टेंसर उत्पन्न करता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#constant

उदाहरण:

%output = mhlo.constant dense<[[0.0, 1.0], [2.0, 3.0]]> : tensor<2x2xf32>

लक्षण: AlwaysSpeculatableImplTrait , ConstantLike

इंटरफेस: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

गुण:

गुण	एमएलआईआर प्रकार	विवरण
`value`	::mlir::ElementsAttr	स्थिर वेक्टर/टेंसर विशेषता

परिणाम:

परिणाम विवरण

output 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक परिमाणित या प्रति-अक्ष पूर्णांक परिमाणित मानों के साथ जटिल प्रकार का स्थिर आकार का टेंसर

`mhlo.convert` (mhlo::ConvertOp)

परिवर्तन ऑपरेशन

वाक्यविन्यास:

operation ::= `mhlo.convert` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

operand टेंसर पर एक तत्व प्रकार से दूसरे तत्व प्रकार में तत्व-वार रूपांतरण करता है और result टेंसर उत्पन्न करता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#convert

उदाहरण:

%result = mhlo.convert %operand : (tensor<3xi32>) -> tensor<3xcomplex<f32>>

लक्षण: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड विवरण

operand 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक परिमाणित या प्रति-अक्ष पूर्णांक परिमाणित मानों के साथ जटिल प्रकार का रैंक किया गया टेंसर

परिणाम:

परिणाम विवरण

result 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक परिमाणित या प्रति-अक्ष पूर्णांक परिमाणित मानों के साथ जटिल प्रकार का रैंक किया गया टेंसर

`mhlo.convolution` (mhlo::ConvolutionOp)

कनवल्शन ऑपरेशन

वाक्यविन्यास:

operation ::= `mhlo.convolution` `(`operands`)`
              `dim_numbers` `=` custom<ConvolutionDimensions>($dimension_numbers) `,`
              `window` `=` `{` custom<WindowAttributes>($window_strides, $padding,
              $lhs_dilation, $rhs_dilation,
              $window_reversal) `}`
              attr-dict `:` functional-type(operands, results)

lhs की विंडो और rhs के स्लाइस के बीच डॉट उत्पादों की गणना करता है और result उत्पन्न करता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#convolution

उदाहरण:

%result = "mhlo.convolution"(%lhs, %rhs) {
  window_strides = dense<4> : tensor<2xi64>,
  padding = dense<0> : tensor<2x2xi64>,
  lhs_dilation = dense<2> : tensor<2xi64>,
  rhs_dilation = dense<1> : tensor<2xi64>,
  window_reversal = dense<false> : tensor<2xi1>,
  dimension_numbers = #mhlo.conv<[b, 0, 1, f]x[0, 1, i, o]->[b, 0, 1, f]>,
  feature_group_count = 1 : i64,
  batch_group_count = 1 : i64,
  precision_config = [#stablehlo<precision DEFAULT>, #stablehlo<precision DEFAULT>]
} : (tensor<1x4x4x1xi32>, tensor<3x3x1x1xi32>) -> tensor<1x2x2x1xi32>

लक्षण: AlwaysSpeculatableImplTrait

इंटरफेस: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

गुण:

गुण	एमएलआईआर प्रकार	विवरण
`window_strides`	::mlir::DenseIntElementsAttr	64-बिट साइनलेस पूर्णांक तत्व विशेषता
`padding`	::mlir::DenseIntElementsAttr	64-बिट साइनलेस पूर्णांक तत्व विशेषता
`lhs_dilation`	::mlir::DenseIntElementsAttr	64-बिट साइनलेस पूर्णांक तत्व विशेषता
`rhs_dilation`	::mlir::DenseIntElementsAttr	64-बिट साइनलेस पूर्णांक तत्व विशेषता
`window_reversal`	::mlir::DenseElementsAttr	स्थिर बूलियन वेक्टर/टेंसर विशेषता
`dimension_numbers`	::mlir::mhlo::ConvDimensionNumbersAttr	रूपांतरण सेशन के लिए आयाम जानकारी की संरचना
`feature_group_count`	::mlir::IntegerAttr	64-बिट साइनलेस पूर्णांक विशेषता जिसका मान सकारात्मक है
`batch_group_count`	::mlir::IntegerAttr	64-बिट साइनलेस पूर्णांक विशेषता जिसका मान सकारात्मक है
`precision_config`	::mlir::ArrayAttr	परिशुद्ध कॉन्फिग विशेषता

ऑपरेंड:

ओपेरंड विवरण

lhs 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक परिमाणित या प्रति-अक्ष पूर्णांक परिमाणित मानों के साथ जटिल प्रकार का रैंक किया गया टेंसर

rhs 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक परिमाणित या प्रति-अक्ष पूर्णांक परिमाणित मानों के साथ जटिल प्रकार का रैंक किया गया टेंसर

परिणाम:

परिणाम

विवरण

«अनाम»

`mhlo.copy` (mhlo::CopyOp)

कॉपी ऑपरेशन

वाक्यविन्यास:

operation ::= `mhlo.copy` operands attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

यह ऑपरेशन XLA कंपाइलर के लिए निजी है, इसलिए इसमें अभी तक कोई विनिर्देश नहीं है।

अनौपचारिक रूप से, यह ऑपरेशन operand की एक प्रति है। ऑपरेशन से जुड़े मेटाडेटा के आधार पर, यह नो-ऑप से काफी अलग व्यवहार कर सकता है।

उदाहरण:

%0 = mhlo.copy %arg0 : tensor<f32>

लक्षण: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

गुण:

गुण	एमएलआईआर प्रकार	विवरण
`cross_program_prefetch_index`	::mlir::IntegerAttr	32-बिट साइनलेस पूर्णांक विशेषता

ऑपरेंड:

ओपेरंड विवरण

operand 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या जटिल प्रकार के 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक परिमाणित या प्रति-अक्ष पूर्णांक परिमाणित मान या टोकन या नेस्टेड ट्यूपल के साथ 4/6/8/16/32/64-बिट के रैंक वाले टेंसर के किसी भी संयोजन के साथ रैंक किया गया टेंसर। फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों के साथ जटिल प्रकार या प्रति-टेंसर पूर्णांक परिमाणित मान या 4/6/8/16/32/64-बिट का मेमरेफ फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर के साथ जटिल प्रकार पूर्णांक परिमाणित मान या प्रति-अक्ष पूर्णांक परिमाणित मान या टोकन का रैंक किया गया टेंसर मूल्य

परिणाम:

परिणाम विवरण

result 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या जटिल प्रकार के 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक परिमाणित या प्रति-अक्ष पूर्णांक परिमाणित मान या टोकन या नेस्टेड ट्यूपल के साथ 4/6/8/16/32/64-बिट के रैंक वाले टेंसर के किसी भी संयोजन के साथ रैंक किया गया टेंसर। फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों के साथ जटिल प्रकार या प्रति-टेंसर पूर्णांक परिमाणित मान या 4/6/8/16/32/64-बिट का मेमरेफ फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर के साथ जटिल प्रकार पूर्णांक परिमाणित मान या प्रति-अक्ष पूर्णांक परिमाणित मान या टोकन का रैंक किया गया टेंसर मूल्य

`mhlo.cosh` (mhlo::CoshOp)

कोष संचालन

वाक्यविन्यास:

operation ::= `mhlo.cosh` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

operand टेंसर पर तत्व-वार कोश ऑपरेशन करता है और result टेंसर उत्पन्न करता है।

उदाहरण:

%result = mhlo.cosh %operand : tensor<2x2xf32>

लक्षण: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

इंटरफ़ेस: InferShapedTypeOpInterface , InferTypeOpInterface

ऑपरेंड:

ओपेरंड	विवरण
`operand`	4/6/8/16/32/64-बिट फ्लोट या 32/64-बिट फ्लोट तत्व मानों के साथ जटिल प्रकार का टेंसर

परिणाम:

परिणाम	विवरण
`result`	4/6/8/16/32/64-बिट फ्लोट या 32/64-बिट फ्लोट तत्व मानों के साथ जटिल प्रकार का टेंसर

`mhlo.cosine` (mhlo::CosineOp)

कोसाइन ऑपरेशन

वाक्यविन्यास:

operation ::= `mhlo.cosine` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

operand टेंसर पर तत्व-वार कोसाइन ऑपरेशन करता है और result टेंसर उत्पन्न करता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#cosine

उदाहरण:

%result = mhlo.cosine %operand : tensor<2xf32>

लक्षण: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

गुण:

गुण	एमएलआईआर प्रकार	विवरण
`result_accuracy`	::mlir::mhlo::ResultAccuracyAttr	यूनरी ऑप्स के लिए अनुरोधित सटीकता।

ऑपरेंड:

ओपेरंड	विवरण
`operand`	4/6/8/16/32/64-बिट फ्लोट या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक परिमाणित मानों के साथ जटिल प्रकार का रैंक किया गया टेंसर

परिणाम:

परिणाम	विवरण
`result`	4/6/8/16/32/64-बिट फ्लोट या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक परिमाणित मानों के साथ जटिल प्रकार का रैंक किया गया टेंसर

`mhlo.count_leading_zeros` (mhlo::ClzOp)

सीएलज़ ऑपरेशन

वाक्यविन्यास:

operation ::= `mhlo.count_leading_zeros` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

operand टेंसर में अग्रणी शून्य बिट्स की संख्या की तत्व-वार गणना करता है और result टेंसर उत्पन्न करता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#count_leading_zeros

उदाहरण:

%result = mhlo.count_leading_zeros %operand : tensor<2x2xi8>

लक्षण: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`operand`	2/4/8/16/32/64-बिट पूर्णांक मानों का रैंक किया गया टेंसर

परिणाम:

परिणाम	विवरण
`result`	2/4/8/16/32/64-बिट पूर्णांक मानों का रैंक किया गया टेंसर

`mhlo.create_token` (mhlo::CreateTokenOp)

क्रिएटटोकन ऑपरेशन

वाक्यविन्यास:

operation ::= `mhlo.create_token` attr-dict `:` type(results)

यह ऑपरेशन StableHLO से बाहर जा रहा है, इसलिए इसे विनिर्देश में शामिल नहीं किया गया है: https://github.com/openxla/stablehlo/issues/3

अनौपचारिक रूप से, यह ऑपरेशन 0 इनपुट के साथ AfterAllOp जैसा ही काम करता है: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#after_all

उदाहरण:

%output = mhlo.create_token : !mhlo.token

लक्षण: AlwaysSpeculatableImplTrait

इंटरफेस: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

परिणाम:

परिणाम	विवरण
`output`	टोकन

`mhlo.cross-replica-sum` (mhlo::CrossReplicaSumOp)

क्रॉसरेप्लिकासम ऑपरेशन

अनौपचारिक रूप से, यह ऑपरेशन channel_id = 0 , use_global_device_ids = false और computation कार्यान्वयन जोड़ के साथ AllReduceOp जैसा ही काम करता है: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_reduce

उदाहरण:

%result = "mhlo.cross-replica-sum"(%operand) {
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>
} : (tensor<4xf32>) -> tensor<4xf32>

लक्षण: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

गुण:

गुण	एमएलआईआर प्रकार	विवरण
`replica_groups`	::mlir::DenseIntElementsAttr	64-बिट साइनलेस पूर्णांक तत्व विशेषता

ऑपरेंड:

ओपेरंड विवरण

परिणाम:

परिणाम

विवरण

«अनाम»

`mhlo.custom_call` (mhlo::CustomCallOp)

कस्टमकॉल ऑपरेशन

वाक्यविन्यास:

operation ::= `mhlo.custom_call` custom<CustomCallTarget>($call_target_name) `(` $inputs `)`
              attr-dict `:` functional-type(operands, results)

एक कार्यान्वयन-परिभाषित ऑपरेशन call_target_name को एनकैप्सुलेट करता है जो inputs लेता है और called_computations लेता है और results उत्पन्न करता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#custom_call

उदाहरण:

%results = "mhlo.custom_call"(%input0) {
  call_target_name = "foo",
  has_side_effect = false,
  backend_config = "bar",
  api_version = 1 : i32,
  called_computations = [@foo]
} : (tensor<f32>) -> tensor<f32>

A custom call invokes code external to XLA. The `inputs` are passed to the
external code, and the external code is expected to produce a result of the
given type. The exact mechanism is backend-specific. For example, in the CPU
backend, a call instruction is emitted which targets a symbol with the name
`call_target_name`.

If XLA runtime is enabled for a backend, then custom calls use the runtime
custom call calling convention to call into the external functions. This
calling convention defines an ABI for encoding arguments, attributes and
results.

Depending on the API version there are two ways to pass extra bits of static
information to the external function:

1. For `API_VERSION_TYPED_FFI` custom calls `backend_config` must be a
   dictionary attribute, that will be encoded according to the custom call
   calling convention and passed to the external function as the attributes
   argument. External code is expected to use declarative bindings (see
   `xla/runtime/custom_call.h`) to decode them at run time. These custom
   calls are only supported if XLA uses XLA runtime.

2. For previous API versions it is the user responsibility to encode extra
   bits of static information as a string `backend_config` attribute, and
   decode it at run time.

इंटरफेस: MemoryEffectOpInterface

गुण:

गुण	एमएलआईआर प्रकार	विवरण
`call_target_name`	::mlir::StringAttr	स्ट्रिंग विशेषता
`has_side_effect`	::mlir::BoolAttr	बूल विशेषता
`backend_config`	::mlir::विशेषता	स्ट्रिंग विशेषता या नामित विशेषता मानों का शब्दकोश
`api_version`	::mlir::mhlo::CustomCallApiVersionAttr	कस्टम कॉल एपीआई संस्करण
`called_computations`	::mlir::ArrayAttr	फ्लैट प्रतीक रेफरी सरणी विशेषता
`custom_call_schedule`	::mlir::mhlo::CustomCallScheduleAttr	कस्टम-कॉल के लिए वांछित शेड्यूल निर्दिष्ट करता है।
`operand_layouts`	::mlir::ArrayAttr	लेआउट की सारणी (सूचकांक प्रकार का 1डी टेंसर) विशेषताएँ
`result_layouts`	::mlir::ArrayAttr	लेआउट की सारणी (सूचकांक प्रकार का 1डी टेंसर) विशेषताएँ
`output_operand_aliases`	::mlir::ArrayAttr	कस्टमकॉल के आउटपुट और ऑपरेंड के लिए एलियासिंग विशेषता

ऑपरेंड:

ओपेरंड विवरण

inputs 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों के साथ जटिल प्रकार या प्रति-टेंसर पूर्णांक परिमाणित या प्रति-अक्ष पूर्णांक परिमाणित मान या 4/6/8/16/32/64-बिट फ्लोट या बूल का मेमरेफ़ के टेन्सर का वैरिएडिक 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों के साथ जटिल प्रकार या प्रति-टेंसर पूर्णांक परिमाणित मान या 4/6/8/16/32/64-बिट फ्लोट या बूल के टेंसर के किसी भी संयोजन के साथ टोकन या नेस्टेड टपल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों के साथ जटिल प्रकार या प्रति-टेंसर पूर्णांक परिमाणित या प्रति-अक्ष पूर्णांक परिमाणित मान या मेम्रेफ़ 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक परिमाणित मान या टोकन मान के साथ जटिल प्रकार

परिणाम:

परिणाम

विवरण

«अनाम»

4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों के साथ जटिल प्रकार या प्रति-टेंसर पूर्णांक परिमाणित या प्रति-अक्ष पूर्णांक परिमाणित मान या 4/6/8/16/32/64-बिट फ्लोट या बूल का मेमरेफ़ के टेन्सर का वैरिएडिक 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों के साथ जटिल प्रकार या प्रति-टेंसर पूर्णांक परिमाणित मान या 4/6/8/16/32/64-बिट फ्लोट या बूल के टेंसर के किसी भी संयोजन के साथ टोकन या नेस्टेड टपल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों के साथ जटिल प्रकार या प्रति-टेंसर पूर्णांक परिमाणित या प्रति-अक्ष पूर्णांक परिमाणित मान या मेम्रेफ़ 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक परिमाणित मान या टोकन मान के साथ जटिल प्रकार

`mhlo.divide` (mhlo::DivOp)

डिव ऑपरेशन

वाक्यविन्यास:

operation ::= `mhlo.divide` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

लाभांश lhs और विभाजक rhs टेंसर का तत्व-वार विभाजन करता है और result टेंसर उत्पन्न करता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#divide

उदाहरण:

%result = mhlo.divide %lhs, %rhs : tensor<4xf32>

लक्षण: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड विवरण

lhs 2/4/8/16/32/64-बिट पूर्णांक या 4/6/8/16/32/64-बिट फ्लोट या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक परिमाणित या प्रति-अक्ष पूर्णांक परिमाणित मानों के साथ जटिल प्रकार का रैंक किया गया टेंसर

rhs 2/4/8/16/32/64-बिट पूर्णांक या 4/6/8/16/32/64-बिट फ्लोट या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक परिमाणित या प्रति-अक्ष पूर्णांक परिमाणित मानों के साथ जटिल प्रकार का रैंक किया गया टेंसर

परिणाम:

परिणाम विवरण

result 2/4/8/16/32/64-बिट पूर्णांक या 4/6/8/16/32/64-बिट फ्लोट या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक परिमाणित या प्रति-अक्ष पूर्णांक परिमाणित मानों के साथ जटिल प्रकार का रैंक किया गया टेंसर

`mhlo.domain` (mhlo::DomainOp)

डोमेन संचालन

यह ऑपरेशन XLA कंपाइलर के लिए निजी है, इसलिए इसमें अभी तक कोई विनिर्देश नहीं है।

अनौपचारिक रूप से, इन परिचालनों का उपयोग निर्देशों को समान DomainMetadata प्रॉपर्टी के साथ समूहित करने के लिए किया जाता है। एक ही डिवाइस पर निर्देशों को समूहीकृत करने के लिए आज शेयरिंगमेटाडेटा मुख्य उपयोग मामला है। डोमेन निर्देश दो प्रमुख लाभ प्रदान करते हैं:

सभी डोमेन में निर्देशों को अनजाने में अनुकूलित करने से रोकें।
डोमेन में बनाए गए निर्देशों का मेटाडेटा स्वचालित रूप से असाइन करें। डोमेन निर्देशों के बिना, प्रत्येक एचएलओ अनुकूलन पास को मेटाडेटा की जांच और प्रचार करना होगा, जिससे चूकना आसान होगा और कंपाइलर में जटिलता भी जुड़ जाएगी। चूंकि डोमेन निर्देश दो अलग-अलग डोमेन को जोड़ते हैं, प्रत्येक डोमेन निर्देश दो डोमेनमेटाडेटा से जुड़ा होता है - एक ऑपरेंड पक्ष पर और एक डोमेन के उपयोगकर्ता पक्ष पर।

लक्षण: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

गुण:

गुण	एमएलआईआर प्रकार	विवरण
`kind`	::mlir::mhlo::DomainKindAttr	HLO डोमेन से जुड़े डोमेन मेटाडेटा का प्रकार।
`entry_metadata`	::mlir::StringAttr	स्ट्रिंग विशेषता
`exit_metadata`	::mlir::StringAttr	स्ट्रिंग विशेषता

ऑपरेंड:

ओपेरंड विवरण

operand 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या जटिल प्रकार का 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक परिमाणित मूल्यों का रैंक किया गया टेंसर या प्रति-अक्ष पूर्णांक परिमाणित मूल्यों या टोकन का रैंक किया गया टेंसर

परिणाम:

परिणाम विवरण

result 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या जटिल प्रकार का 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक परिमाणित मूल्यों का रैंक किया गया टेंसर या प्रति-अक्ष पूर्णांक परिमाणित मूल्यों या टोकन का रैंक किया गया टेंसर

`mhlo.dot` (mhlo::DotOp)

डॉट ऑपरेशन

अनौपचारिक रूप से, यह ऑपरेशन XLA के डॉट के समान ही कार्य करता है: https://www.tensorflow.org/xla/operation_semantics#dot

उदाहरण:

%0 = mhlo.dot %arg0, %arg1 : (tensor<1x2xi32>, tensor<2x1xi32>) -> tensor<1x1xi32>

लक्षण: AlwaysSpeculatableImplTrait

इंटरफेस: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

गुण:

गुण	एमएलआईआर प्रकार	विवरण
`precision_config`	::mlir::ArrayAttr	परिशुद्ध कॉन्फिग विशेषता

ऑपरेंड:

ओपेरंड विवरण

परिणाम:

परिणाम

विवरण

«अनाम»

`mhlo.dot_general` (mhlo::DotGeneralOp)

डॉटजनरल ऑपरेशन

lhs के स्लाइस और rhs के स्लाइस के बीच डॉट उत्पादों की गणना करता है और एक result टेंसर उत्पन्न करता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dot_general

उदाहरण:

%result = "mhlo.dot_general"(%lhs, %rhs) {
  dot_dimension_numbers = #mhlo.dot<
    lhs_batching_dimensions = [0],
    rhs_batching_dimensions = [0],
    lhs_contracting_dimensions = [2],
    rhs_contracting_dimensions = [1]
  >,
  precision_config = [#stablehlo<precision DEFAULT>, #stablehlo<precision DEFAULT>]
} : (tensor<2x2x2xi32>, tensor<2x2x2xi32>) -> tensor<2x2x2xi32>

लक्षण: AlwaysSpeculatableImplTrait

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

गुण:

गुण	एमएलआईआर प्रकार	विवरण
`dot_dimension_numbers`	::mlir::mhlo::DotDimensionNumbersAttr	वह विशेषता जो डॉट के लिए आयाम जानकारी को मॉडल करती है।
`precision_config`	::mlir::ArrayAttr	परिशुद्ध कॉन्फिग विशेषता
`algorithm`	::mlir::mhlo::DotAlgorithmAttr	विशेषताएँ जो कंप्यूटिंग डॉट के लिए उपयोग करने के लिए एल्गोरिदम बाधाओं को मॉडल करती हैं।

ऑपरेंड:

ओपेरंड विवरण

परिणाम:

परिणाम

विवरण

«अनाम»

`mhlo.dynamic_broadcast_in_dim` (mhlo::DynamicBroadcastInDimOp)

डायनामिकब्रॉडकास्टइनडिम ऑपरेशन

यह ऑपरेशन कार्यात्मक रूप से ब्रॉडकास्ट_इन_डिम ऑप के समान है, लेकिन परिणाम आकार output_dimensions के माध्यम से गतिशील रूप से निर्दिष्ट किया जाता है।

यह आयामों के विस्तारित व्यवहार के बारे में स्थैतिक ज्ञान व्यक्त करने के लिए वैकल्पिक विशेषताओं को भी स्वीकार करता है। यदि निर्दिष्ट नहीं किया गया है, तो यह माना जाता है कि सभी आयाम संभवतः विस्तारित हो रहे हैं। आयामों के वे सेट जिन्हें विस्तार के रूप में जाना जाता है और आयामों के सेट को गैर-विस्तार के रूप में जाना जाता है, उन्हें असंबद्ध होना चाहिए और उन्हें ऑपरेंड के आयामों का एक उपसमूह होना चाहिए।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_broadcast_in_dim

उदाहरण:

%operand = mhlo.constant dense<[[1, 2, 3]]> : tensor<1x3xi64>
%output_dimensions = mhlo.constant dense<[2, 3, 2]> : tensor<3xi64>
%result = "mhlo.dynamic_broadcast_in_dim"(%operand, %output_dimensions) {
  broadcast_dimensions = array<i64: 2, 1>,
  known_expanding_dimensions = array<i64: 0>,
  known_nonexpanding_dimensions = array<i64: 1>
} : (tensor<1x3xi64>, tensor<3xi64>) -> tensor<2x3x2xi64>

लक्षण: AlwaysSpeculatableImplTrait

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

गुण:

गुण	एमएलआईआर प्रकार	विवरण
`broadcast_dimensions`	::mlir::DenseIntElementsAttr	64-बिट साइनलेस पूर्णांक तत्व विशेषता
`known_expanding_dimensions`	::mlir::DenseIntElementsAttr	64-बिट साइनलेस पूर्णांक तत्व विशेषता
`known_nonexpanding_dimensions`	::mlir::DenseIntElementsAttr	64-बिट साइनलेस पूर्णांक तत्व विशेषता

ऑपरेंड:

ओपेरंड विवरण

output_dimensions सूचकांक का 1D टेंसर या 2/4/8/16/32/64-बिट पूर्णांक मान

परिणाम:

परिणाम

विवरण

«अनाम»

`mhlo.dynamic_conv` (mhlo::DynamicConvOp)

डायनामिककॉन्व ऑपरेशन

इस ऑपरेशन पर काम चल रहा है, इसलिए इसे अभी तक विनिर्देश में शामिल नहीं किया गया है: https://github.com/openxla/stablehlo/issues/8

अनौपचारिक रूप से, यह ऑपरेशन ConvolutionOp के समान ही कार्य करता है, सिवाय इसके कि padding d_padding के माध्यम से गतिशील रूप से निर्दिष्ट किया जाता है: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#convolution

उदाहरण:

%result = "mhlo.dynamic_conv"(%lhs, %rhs, %d_padding) {
  window_strides = dense<4> : tensor<2xi64>,
  lhs_dilation = dense<2> : tensor<2xi64>,
  rhs_dilation = dense<1> : tensor<2xi64>,
  window_reversal = dense<false> : tensor<2xi1>,
  dimension_numbers = #mhlo.conv<[b, 0, 1, f]x[0, 1, i, o]->[b, 0, 1, f]>,
  feature_group_count = 1 : i64,
  batch_group_count = 1 : i64,
  precision_config = [#stablehlo<precision DEFAULT>, #stablehlo<precision DEFAULT>]
} : (tensor<1x4x4x1xi32>, tensor<3x3x1x1xi32>, tensor<2x2xi64>) -> tensor<1x2x2x1xi32>

लक्षण: AlwaysSpeculatableImplTrait

इंटरफेस: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

गुण:

गुण	एमएलआईआर प्रकार	विवरण
`window_strides`	::mlir::DenseIntElementsAttr	64-बिट साइनलेस पूर्णांक तत्व विशेषता
`padding`	::mlir::DenseIntElementsAttr	64-बिट साइनलेस पूर्णांक तत्व विशेषता
`lhs_dilation`	::mlir::DenseIntElementsAttr	64-बिट साइनलेस पूर्णांक तत्व विशेषता
`rhs_dilation`	::mlir::DenseIntElementsAttr	64-बिट साइनलेस पूर्णांक तत्व विशेषता
`window_reversal`	::mlir::DenseElementsAttr	स्थिर बूलियन वेक्टर/टेंसर विशेषता
`dimension_numbers`	::mlir::mhlo::ConvDimensionNumbersAttr	रूपांतरण सेशन के लिए आयाम जानकारी की संरचना
`feature_group_count`	::mlir::IntegerAttr	64-बिट साइनलेस पूर्णांक विशेषता जिसका मान सकारात्मक है
`batch_group_count`	::mlir::IntegerAttr	64-बिट साइनलेस पूर्णांक विशेषता जिसका मान सकारात्मक है
`precision_config`	::mlir::ArrayAttr	परिशुद्ध कॉन्फिग विशेषता

ऑपरेंड:

ओपेरंड	विवरण
`lhs`	4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक परिमाणित या प्रति-अक्ष पूर्णांक परिमाणित मानों के साथ जटिल प्रकार का रैंक किया गया टेंसर
`rhs`	4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक परिमाणित या प्रति-अक्ष पूर्णांक परिमाणित मानों के साथ जटिल प्रकार का रैंक किया गया टेंसर
`d_padding`	4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक परिमाणित या प्रति-अक्ष पूर्णांक परिमाणित मानों के साथ जटिल प्रकार का रैंक किया गया टेंसर

परिणाम:

परिणाम

विवरण

«अनाम»

`mhlo.dynamic_gather` (mhlo::DynamicGatherOp)

डायनामिकगैदर ऑपरेशन

अनौपचारिक रूप से, यह ऑपरेशन GatherOp जैसा ही काम करता है, सिवाय इसके कि slice_sizes गतिशील रूप से निर्दिष्ट होते हैं: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#gather

उदाहरण:

%result = "mhlo.dynamic_gather"(%operand, %start_indices, %slice_sizes) {
  dimension_numbers = #mhlo.gather<
    offset_dims = [2, 3],
    collapsed_slice_dims = [0],
    start_index_map = [0, 2],
    index_vector_dim = 2>,
  indices_are_sorted = false
} : (tensor<3x4x2xi32>, tensor<2x3x2xi64>, tensor<3xi64>) -> tensor<2x3x2x2xi32>

लक्षण: AlwaysSpeculatableImplTrait , InferTensorType

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

गुण:

गुण	एमएलआईआर प्रकार	विवरण
`dimension_numbers`	::mlir::mhlo::GatherDimensionNumbersAttr	वह विशेषताएँ जो इकट्ठा करने के लिए आयाम जानकारी को मॉडल करती हैं
`indices_are_sorted`	::mlir::BoolAttr	बूल विशेषता

ऑपरेंड:

ओपेरंड	विवरण
`operand`	4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक परिमाणित या प्रति-अक्ष पूर्णांक परिमाणित मानों के साथ जटिल प्रकार का रैंक किया गया टेंसर
`start_indices`	2/4/8/16/32/64-बिट पूर्णांक मानों का रैंक किया गया टेंसर
`slice_sizes`	2/4/8/16/32/64-बिट पूर्णांक मानों का स्थिर आकार वाला 1-आयामी पूर्णांक टेंसर

परिणाम:

परिणाम

विवरण

«अनाम»

`mhlo.dynamic_iota` (mhlo::DynamicIotaOp)

डायनामिकआईओटा ऑपरेशन

यह ऑपरेशन कार्यात्मक रूप से iota op के समान है, लेकिन परिणाम आकार output_shape के माध्यम से गतिशील रूप से निर्दिष्ट किया जाता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_iota

उदाहरण:

%0 = mhlo.dynamic_iota %arg0, dim = 0 : (tensor<1xindex>) -> tensor<4xi32>

लक्षण: AlwaysSpeculatableImplTrait

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

गुण:

गुण	एमएलआईआर प्रकार	विवरण
`iota_dimension`	::mlir::IntegerAttr	64-बिट साइनलेस पूर्णांक विशेषता जिसका मान गैर-नकारात्मक है

ऑपरेंड:

ओपेरंड	विवरण
`output_shape`	सूचकांक का 1D टेंसर या 2/4/8/16/32/64-बिट पूर्णांक मान

परिणाम:

परिणाम विवरण

`mhlo.dynamic_pad` (mhlo::DynamicPadOp)

डायनामिकपैड ऑपरेशन

वाक्यविन्यास:

operation ::= `mhlo.dynamic_pad` operands attr-dict `:` functional-type(operands, results)

operand गतिशील रूप से पैड करता है, लो-एंड/हाई-एंड/इंटीरियर पर जोड़ी गई पैडिंग की मात्रा को इनपुट टेंसर के माध्यम से पारित किया जाता है।

लक्षण: AlwaysSpeculatableImplTrait

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`operand`	4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक परिमाणित या प्रति-अक्ष पूर्णांक परिमाणित मानों के साथ जटिल प्रकार का रैंक किया गया टेंसर
`padding_value`	4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक परिमाणित या प्रति-अक्ष पूर्णांक परिमाणित मानों के साथ जटिल प्रकार का रैंक किया गया टेंसर
`edge_padding_low`	सूचकांक का 1D टेंसर या 2/4/8/16/32/64-बिट पूर्णांक मान
`edge_padding_high`	सूचकांक का 1D टेंसर या 2/4/8/16/32/64-बिट पूर्णांक मान
`interior_padding`	सूचकांक का 1D टेंसर या 2/4/8/16/32/64-बिट पूर्णांक मान

परिणाम:

परिणाम विवरण

`mhlo.dynamic_reshape` (mhlo::DynamicReshapeOp)

डायनामिक रीशेप ऑपरेशन

वाक्यविन्यास:

operation ::= `mhlo.dynamic_reshape` operands attr-dict `:` functional-type(operands, results)

यह ऑपरेशन कार्यात्मक रूप से reshape op के समान है, लेकिन परिणाम आकार को output_shape के माध्यम से गतिशील रूप से निर्दिष्ट किया जाता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_reshape

उदाहरण:

%output_shape = mhlo.constant dense<[3, 2]> : tensor<2xi64>
%result = mhlo.dynamic_reshape %operand, %output_shape : (tensor<2x3xi64>, tensor<2xi64>) -> tensor<3x2xi64>

लक्षण: AlwaysSpeculatableImplTrait

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड विवरण

operand 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों के साथ जटिल प्रकार का टेंसर या प्रति-टेंसर पूर्णांक परिमाणित या प्रति-अक्ष पूर्णांक परिमाणित मान

output_shape सूचकांक का 1D टेंसर या 2/4/8/16/32/64-बिट पूर्णांक मान

परिणाम:

परिणाम विवरण

result 4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों के साथ जटिल प्रकार का टेंसर या प्रति-टेंसर पूर्णांक परिमाणित या प्रति-अक्ष पूर्णांक परिमाणित मान

`mhlo.dynamic_slice` (mhlo::DynamicSliceOp)

डायनामिकस्लाइस ऑपरेशन

गतिशील रूप से गणना किए गए प्रारंभिक सूचकांकों का उपयोग करके operand से एक स्लाइस निकालता है और एक result टेंसर उत्पन्न करता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_slice

उदाहरण:

%result = mhlo.dynamic_slice %operand, %start_indices0, %start_indices1, sizes = [2, 2]
  : (tensor<4x4xi32>, tensor<i64>, tensor<i64>) -> tensor<2x2xi32>

लक्षण: AlwaysSpeculatableImplTrait , InferTensorType

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

गुण:

गुण	एमएलआईआर प्रकार	विवरण
`slice_sizes`	::mlir::DenseIntElementsAttr	64-बिट साइनलेस पूर्णांक तत्व विशेषता

ऑपरेंड:

ओपेरंड विवरण

start_indices 2/4/8/16/32/64-बिट पूर्णांक मानों के 0D टेंसर का वैरिएडिक

परिणाम:

परिणाम विवरण

`mhlo.dynamic_update_slice` (mhlo::DynamicUpdateSliceOp)

डायनामिकअपडेटस्लाइस ऑपरेशन

वाक्यविन्यास:

operation ::= `mhlo.dynamic_update_slice` operands attr-dict `:` functional-type(operands, results)

एक result टेंसर उत्पन्न करता है जो operand टेंसर के बराबर होता है, सिवाय इसके कि start_indices से शुरू होने वाला स्लाइस update में मानों के साथ अपडेट किया जाता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#dynamic_update_slice

उदाहरण:

%result = mhlo.dynamic_update_slice %operand, %update, %start_indices0, %start_indices1
  : (tensor<4x4xi32>, tensor<2x2xi32>, tensor<i64>, tensor<i64>) -> tensor<4x4xi32>

लक्षण: AlwaysSpeculatableImplTrait , InferTensorType

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`operand`	4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक परिमाणित या प्रति-अक्ष पूर्णांक परिमाणित मानों के साथ जटिल प्रकार का रैंक किया गया टेंसर
`update`	4/6/8/16/32/64-बिट फ्लोट या बूल या 2/4/8/16/32/64-बिट पूर्णांक या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक परिमाणित या प्रति-अक्ष पूर्णांक परिमाणित मानों के साथ जटिल प्रकार का रैंक किया गया टेंसर
`start_indices`	2/4/8/16/32/64-बिट पूर्णांक मानों के 0D टेंसर का वैरिएडिक

परिणाम:

परिणाम विवरण

`mhlo.einsum` (mhlo::EinsumOp)

आइंसम ऑपरेशन

अनौपचारिक रूप से, यह ऑपरेशन TF के einsum के समान ही कार्य करता है: https://www.tensorflow.org/api_docs/python/tf/einsum

उदाहरण:

%result = "mhlo.einsum"(%lhs, %rhs) {
  einsum_config = "ab,bc->ac"
} : (tensor<4x16xf32>, tensor<16x4xf32>) -> tensor<4x4xf32>

लक्षण: AlwaysSpeculatableImplTrait

इंटरफेस: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

गुण:

गुण	एमएलआईआर प्रकार	विवरण
`einsum_config`	::mlir::StringAttr	स्ट्रिंग विशेषता

ऑपरेंड:

ओपेरंड विवरण

परिणाम:

परिणाम

विवरण

«अनाम»

`mhlo.erf` (mhlo::ErfOp)

एरफ ऑपरेशन

वाक्यविन्यास:

operation ::= `mhlo.erf` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

operand टेंसर पर तत्व-वार ईआरएफ ऑपरेशन करता है और result टेंसर उत्पन्न करता है।

उदाहरण:

%result = mhlo.erf %operand : tensor<2x2xf32>

लक्षण: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`operand`	4/6/8/16/32/64-बिट फ्लोट मानों का रैंक किया गया टेंसर

परिणाम:

परिणाम	विवरण
`result`	4/6/8/16/32/64-बिट फ्लोट मानों का रैंक किया गया टेंसर

`mhlo.exponential` (mhlo::ExpOp)

ऍक्स्प ऑपरेशन

वाक्यविन्यास:

operation ::= `mhlo.exponential` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

operand टेंसर पर तत्व-वार घातीय संचालन करता है और result टेंसर उत्पन्न करता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#exponential

उदाहरण:

%result = mhlo.exponential %operand : tensor<2x2xf64>

लक्षण: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

इंटरफेस: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

प्रभाव: MemoryEffects::Effect{}

गुण:

गुण	एमएलआईआर प्रकार	विवरण
`result_accuracy`	::mlir::mhlo::ResultAccuracyAttr	यूनरी ऑप्स के लिए अनुरोधित सटीकता।

ऑपरेंड:

ओपेरंड	विवरण
`operand`	4/6/8/16/32/64-बिट फ्लोट या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक परिमाणित मानों के साथ जटिल प्रकार का रैंक किया गया टेंसर

परिणाम:

परिणाम	विवरण
`result`	4/6/8/16/32/64-बिट फ्लोट या 32/64-बिट फ्लोट तत्वों या प्रति-टेंसर पूर्णांक परिमाणित मानों के साथ जटिल प्रकार का रैंक किया गया टेंसर

`mhlo.exponential_minus_one` (mhlo::Expm1Op)

एक्सपीएम1 ऑपरेशन

वाक्यविन्यास:

operation ::= `mhlo.exponential_minus_one` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

operand टेंसर पर तत्व-वार घातीय शून्य से एक ऑपरेशन निष्पादित करता है और एक result टेंसर उत्पन्न करता है।

देखें: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#exponential_minus_one

उदाहरण:

%result = mhlo.exponential_minus_one %operand : tensor<2xf32>

लक्षण: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

गुण:

गुण	MLIR Type	विवरण
`result_accuracy`	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

`mhlo.fft` (mhlo::FftOp)

Fft operation

Performs the forward and inverse Fourier transforms for real and complex inputs/outputs.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#fft

उदाहरण:

%result = mhlo.fft %operand, type = FFT, length = [4] : (tensor<4xcomplex<f32>>) -> tensor<4xcomplex<f32>>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

गुण:

गुण	MLIR Type	विवरण
`fft_type`	::mlir::mhlo::FftTypeAttr	XLA fast fourier transform type.
`fft_length`	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

परिणाम:

परिणाम	विवरण
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

`mhlo.floor` (mhlo::FloorOp)

Floor operation

वाक्यविन्यास:

operation ::= `mhlo.floor` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise floor of operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#floor

उदाहरण:

%result = mhlo.floor %operand : tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 4/6/8/16/32/64-bit float or per-tensor integer quantized values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 4/6/8/16/32/64-bit float or per-tensor integer quantized values

`mhlo.fusion` (mhlo::FusionOp)

Fusion operation

This operation is private to the XLA compiler, so it is does not yet have a specification.

Informally, this operation consists of a group of basic ops (represented as a region attached to it). It serves as a hint to the backend that it is beneficial to emit the contained ops into a single loop nest or kernel.

गुण:

गुण	MLIR Type	विवरण
`fusion_kind`	::mlir::mhlo::FusionKindAttr	fusion kind
`output_operand_aliases`	::mlir::ArrayAttr	Aliasing attribute for outputs and operands of Fusion

ऑपरेंड:

ओपेरंड	विवरण
`inputs`	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

परिणाम:

परिणाम विवरण

results variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values

`mhlo.gather` (mhlo::GatherOp)

Gather operation

Gathers slices from operand tensor from offsets specified in start_indices and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#gather

उदाहरण:

%result = "mhlo.gather"(%operand, %start_indices) {
  dimension_numbers = #stablehlo.gather<
    offset_dims = [3, 4],
    collapsed_slice_dims = [1],
    operand_batching_dims = [0],
    start_indices_batching_dims = [1],
    start_index_map = [2, 1],
    index_vector_dim = 3>,
  slice_sizes = dense<[0, 2, 2]> : tensor<3xi64>,
  indices_are_sorted = false
} : (tensor<2x3x4x2xi64>, tensor<2x2x3x2xi64>) -> tensor<2x2x3x2x2xi64>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

गुण:

गुण	MLIR Type	विवरण
`dimension_numbers`	::mlir::mhlo::GatherDimensionNumbersAttr	Attribute that models the dimension information for gather
`slice_sizes`	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
`indices_are_sorted`	::mlir::BoolAttr	bool attribute

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
`start_indices`	ranked tensor of 2/4/8/16/32/64-bit integer values

परिणाम:

परिणाम	विवरण
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

`mhlo.get_dimension_size` (mhlo::GetDimensionSizeOp)

GetDimensionSize operation

Produces the size of the given dimension of the operand .

See https://github.com/openxla/stablehlo/blob/main/docs/spec.md#get_dimension_size

उदाहरण:

%result = mhlo.get_dimension_size %operand, dim = 1 : (tensor<2x3xf32>) -> tensor<i32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

गुण:

गुण	MLIR Type	विवरण
`dimension`	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

परिणाम:

परिणाम	विवरण
«unnamed»	tensor of 32-bit signless integer values

`mhlo.get_tuple_element` (mhlo::GetTupleElementOp)

GetTupleElement operation

वाक्यविन्यास:

operation ::= `mhlo.get_tuple_element` $operand `[` $index `]` attr-dict `:` functional-type(operands, results)

Extracts element at index position of the operand tuple and produces a result .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#get_tuple_element

उदाहरण:

%result = mhlo.get_tuple_element %operand[0] : (tuple<tensor<2xf32>, tuple<tensor<i32>>>) -> tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

गुण:

गुण	MLIR Type	विवरण
`index`	::mlir::IntegerAttr	32-bit signless integer attribute whose value is non-negative

ऑपरेंड:

ओपेरंड विवरण

operand nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values

परिणाम:

परिणाम

विवरण

«unnamed»

ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token or nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

`mhlo.if` (mhlo::IfOp)

If operation

Produces the output from executing exactly one branch from true_branch or false_branch depending on the value of pred .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#if

Example: %result = "mhlo.if"(%pred) ({ "mhlo.return"(%result_true_branch) : (tensor ) -> () }, { "mhlo.return"(%result_false_branch) : (tensor ) -> () }) : (tensor ) -> tensor

Traits: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferTypeOpInterface

ऑपरेंड:

ओपेरंड	विवरण
`pred`	ranked tensor of bool values

परिणाम:

परिणाम	विवरण
«unnamed»	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

`mhlo.imag` (mhlo::ImagOp)

Imag operation

वाक्यविन्यास:

operation ::= `mhlo.imag` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Extracts the imaginary part, element-wise, from the operand and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#imag

उदाहरण:

%result = mhlo.imag %operand : (tensor<2xcomplex<f32>>) -> tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 4/6/8/16/32/64-bit float values

`mhlo.infeed` (mhlo::InfeedOp)

Infeed operation

Reads data from the infeed and produces results .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#infeed

उदाहरण:

%results:2 = "mhlo.infeed"(%token) {
  infeed_config = ""
} : (!mhlo.token) -> (tensor<3x3x3xi32>, !mhlo.token)

गुण:

गुण	MLIR Type	विवरण
`infeed_config`	::mlir::StringAttr	string attribute
`layout`	::mlir::ArrayAttr	array attribute

ऑपरेंड:

ओपेरंड	विवरण
`token`	टोकन

परिणाम:

परिणाम

विवरण

«unnamed»

variadic of statically shaped tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or statically shaped tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token

`mhlo.iota` (mhlo::IotaOp)

Iota operation

Fills an output tensor with values in increasing order starting from zero along the iota_dimension dimension.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#iota

उदाहरण:

%output = mhlo.iota dim = 0 : tensor<4x5xi32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

गुण:

गुण	MLIR Type	विवरण
`iota_dimension`	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative

परिणाम:

परिणाम	विवरण
`output`	statically shaped tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

`mhlo.is_finite` (mhlo::IsFiniteOp)

IsFinite operation

वाक्यविन्यास:

operation ::= `mhlo.is_finite` $x attr-dict `:` functional-type(operands, results)

Performs element-wise check whether the value in x is finite (ie is neither +Inf, -Inf, nor NaN) and produces a y tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#is_finite

उदाहरण:

%y = mhlo.is_finite %x : (tensor<7xf32>) -> tensor<7xi1>

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`x`	ranked tensor of 4/6/8/16/32/64-bit float values

परिणाम:

परिणाम	विवरण
`y`	ranked tensor of bool values

`mhlo.log` (mhlo::LogOp)

Log operation

वाक्यविन्यास:

operation ::= `mhlo.log` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise logarithm operation on operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#log

उदाहरण:

%result = mhlo.log %operand : tensor<2x2xf64>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

गुण:

गुण	MLIR Type	विवरण
`result_accuracy`	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

`mhlo.log_plus_one` (mhlo::Log1pOp)

Log1p operation

वाक्यविन्यास:

operation ::= `mhlo.log_plus_one` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise logarithm plus one operation on operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#log_plus_one

उदाहरण:

%result = mhlo.log_plus_one %operand : tensor<6xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

गुण:

गुण	MLIR Type	विवरण
`result_accuracy`	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

`mhlo.logistic` (mhlo::LogisticOp)

Logistic operation

वाक्यविन्यास:

operation ::= `mhlo.logistic` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise logistic operation on operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#logistic

उदाहरण:

%result = mhlo.logistic %operand : tensor<2x2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

गुण:

गुण	MLIR Type	विवरण
`result_accuracy`	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

`mhlo.map` (mhlo::MapOp)

Map operation

Applies a map function computation to inputs along the dimensions and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#map

उदाहरण:

%result = "mhlo.map"(%input0, %input1) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = mhlo.multiply %arg0, %arg1 : tensor<i32>
    mhlo.return %0 : tensor<i32>
}) {
  dimensions = dense<[0, 1]> : tensor<2xi64>
} : (tensor<2x2xi32>, tensor<2x2xi32>) -> tensor<2x2xi32>

Traits: InferTensorType , RecursiveMemoryEffects , SameOperandsAndResultShape , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

गुण:

गुण	MLIR Type	विवरण
`dimensions`	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

ऑपरेंड:

ओपेरंड	विवरण
`inputs`	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

परिणाम:

परिणाम	विवरण
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

`mhlo.maximum` (mhlo::MaxOp)

Max operation

वाक्यविन्यास:

operation ::= `mhlo.maximum` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

Performs element-wise max operation on tensors lhs and rhs and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#maximum

उदाहरण:

%result = mhlo.maximum %lhs, %rhs : tensor<4xf32>

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`lhs`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
`rhs`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

`mhlo.minimum` (mhlo::MinOp)

Min operation

वाक्यविन्यास:

operation ::= `mhlo.minimum` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

Performs element-wise min operation on tensors lhs and rhs and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#minimum

उदाहरण:

%result = mhlo.minimum %lhs, %rhs : tensor<4xf32>

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`lhs`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
`rhs`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

`mhlo.minimum_broadcast_shapes` (mhlo::MinimumBroadcastShapesOp)

Minimizes the rank of two or more shapes to be broadcasted

वाक्यविन्यास:

operation ::= `mhlo.minimum_broadcast_shapes` $shapes attr-dict `:` type($shapes) `->` type($results)

Given two or more 1D tensors representing shapes, returns one 1D tensor for each operand, where operand i corresponds to output i .

The returned tensors have the property that they specify a shape which is a reshape of the corresponding input shape, and the broadcasted output shape (using shape::BroadcastOp) of the returned shapes is a reshape of the broadcasted output shape of the input shapes. Among all possibilities with this property, the one is chosen which minimizes the rank of each returned shape.

The general idea of this op is that it can be used for ops which have a broadcasting semantic to operate on shapes with a possibly smaller rank while preserving equivalence of the computed values. After computing the result of the op using reshaped operands, the result can be reshaped to the result that would have been originally computed.

Here is an example with two input shapes:

mhlo.minimum_broadcast_shapes [1, 2, 3, 1, 2, 1],
                                 [1, 1, 1, 2, 3] -> [6, 2, 1], [2, 3]

The broadcasted output shape of the operands is [1, 2, 3, 1, 2, 3], the broadcasted output shape of the outputs is [6, 2, 3]. These two shapes are reshapes of each other, and also each output is a reshape of the corresponding input.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`shapes`	variadic of 1D tensor of index values

परिणाम:

परिणाम	विवरण
`results`	variadic of 1D tensor of index values

`mhlo.multiply` (mhlo::MulOp)

Mul operation

वाक्यविन्यास:

operation ::= `mhlo.multiply` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

Performs element-wise product of two tensors lhs and rhs and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#multiply

उदाहरण:

%result = mhlo.multiply %lhs, %rhs : tensor<2xi32>

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`lhs`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
`rhs`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

`mhlo.negate` (mhlo::NegOp)

Neg operation

वाक्यविन्यास:

operation ::= `mhlo.negate` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise negation of operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#negate

उदाहरण:

%result = mhlo.negate %operand : tensor<2x3xi32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

`mhlo.not` (mhlo::NotOp)

ऑपरेशन नहीं

वाक्यविन्यास:

operation ::= `mhlo.not` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise NOT of tensor operand of type integer and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#not

उदाहरण:

%result = mhlo.not %operand : tensor<5x3x1xi1>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

`mhlo.optimization_barrier` (mhlo::OptimizationBarrierOp)

OptimizationBarrier operation

वाक्यविन्यास:

operation ::= `mhlo.optimization_barrier` attr-dict ($operand^ `:` custom<PairwiseOpType>(type($operand), type($result))):(`(` `)`)?

Ensures that the operations that produce the operand are executed before any operations that depend on the result and prevents compiler transformations from moving operations across the barrier. Other than that, the operation is an identity, ie result = operand .

See https://github.com/openxla/stablehlo/blob/main/docs/spec.md#optimization_barrier

उदाहरण:

%result0, %result1 = mhlo.optimization_barrier %operand0, %operand1 : tensor<f32>, tensor<f32>

Traits: AlwaysSpeculatableImplTrait , HLO_PairwiseSameOperandAndResultType

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`operand`	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

परिणाम:

परिणाम	विवरण
`result`	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token

`mhlo.or` (mhlo::OrOp)

Or operation

वाक्यविन्यास:

operation ::= `mhlo.or` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

Performs element-wise OR of two tensors lhs and rhs and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#or

उदाहरण:

%result = mhlo.or %lhs, %rhs : tensor<2xi1>

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`lhs`	ranked tensor of bool or 2/4/8/16/32/64-bit integer values
`rhs`	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

`mhlo.outfeed` (mhlo::OutfeedOp)

Outfeed operation

Writes inputs to the outfeed and produces a result token.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#outfeed

उदाहरण:

%result = "mhlo.outfeed"(%input0, %token) {
  outfeed_config = ""
} : (tensor<3x3x3xi32>, !mhlo.token) -> !mhlo.token

Interfaces: InferTypeOpInterface

गुण:

गुण	MLIR Type	विवरण
`outfeed_config`	::mlir::StringAttr	string attribute

ऑपरेंड:

ओपेरंड	विवरण
`inputs`	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
`token`	टोकन

परिणाम:

परिणाम	विवरण
«unnamed»	टोकन

`mhlo.pad` (mhlo::PadOp)

Pad operation

Expands operand by padding around the tensor as well as between the elements of the tensor with the given padding_value .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#pad

उदाहरण:

%0 = mhlo.pad %arg0, %arg1, low = [0, 1], high = [2, 1], interior = [1, 2]
  : (tensor<2x3xi32>, tensor<i32>) -> tensor<5x9xi32>

Traits: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

गुण:

गुण	MLIR Type	विवरण
`edge_padding_low`	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
`edge_padding_high`	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
`interior_padding`	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
`padding_value`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

परिणाम:

परिणाम	विवरण
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

`mhlo.partition_id` (mhlo::PartitionIdOp)

PartitionId operation

वाक्यविन्यास:

operation ::= `mhlo.partition_id` attr-dict `:` type(results)

Produces partition_id of the current process.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#partition_id

उदाहरण:

%result = mhlo.partition_id : tensor<ui32>

Interfaces: InferTypeOpInterface

परिणाम:

परिणाम	विवरण
«unnamed»	ranked tensor of 32-bit unsigned integer values

`mhlo.popcnt` (mhlo::PopulationCountOp)

PopulationCount operation

वाक्यविन्यास:

operation ::= `mhlo.popcnt` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise count of the number of bits set in the operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#popcnt

उदाहरण:

%result = mhlo.popcnt %operand : tensor<4xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 2/4/8/16/32/64-bit integer values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 2/4/8/16/32/64-bit integer values

`mhlo.power` (mhlo::PowOp)

Pow operation

वाक्यविन्यास:

operation ::= `mhlo.power` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

Performs element-wise exponentiation of lhs tensor by rhs tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#power

उदाहरण:

%result = mhlo.power %lhs, %rhs : tensor<6xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`lhs`	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
`rhs`	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

`mhlo.ragged_dot` (mhlo::RaggedDotOp)

Ragged matrix multiplication over a single ragged dimension

This operation takes three tensor args---lhs, rhs, and group_sizes---and a "ragged_dot_dimension_numbers" attribute. Like dot_general, the lhs and rhs are allowed arbitrary batch and contracting dimensions. Additionally, the lhs is required to have one ragged dimension, and the rhs may have at most one group dimension. The op has three modes, depending on the kind of the lhs ragged dimension.

In mode 1, the shape-signature is [b,m,k], [g,b,k,n], [b,g] -> [b,m,n] . Here the ragged dimension is an lhs non-contracting dimension ( m ). The dimensions b and k represent batch and contracting dimensions respectively. The rhs is required to have a group dimension ( g ).

In mode 2, the shape-signature is [b,m,k], [b,k,n], [b,g] -> [g,b,m,n] . Here the ragged dimension is an lhs/rhs contracting dimension ( k ).

In mode 3, the shape-signature is [b,m,k], [b,k,n], [g] -> [b,m,n] . Here the ragged dimension is an lhs/rhs batch dimension ( b ).

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

गुण:

गुण	MLIR Type	विवरण
`ragged_dot_dimension_numbers`	::mlir::mhlo::RaggedDotDimensionNumbersAttr	Attribute that models the dimension information for ragged dot.
`precision_config`	::mlir::ArrayAttr	Precision Config attribute

ऑपरेंड:

ओपेरंड	विवरण
`lhs`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
`rhs`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
`group_sizes`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

`mhlo.real` (mhlo::RealOp)

Real operation

वाक्यविन्यास:

operation ::= `mhlo.real` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Extracts the real part, element-wise, from the operand and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#real

उदाहरण:

%result = mhlo.real %operand : (tensor<2xcomplex<f32>>) -> tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 4/6/8/16/32/64-bit float values

`mhlo.real_dynamic_slice` (mhlo::RealDynamicSliceOp)

RealDynamicSlice operation

वाक्यविन्यास:

operation ::= `mhlo.real_dynamic_slice` operands attr-dict `:` functional-type(operands, results)

This operation is a work in progress, so it is not yet included in the specification: https://github.com/openxla/stablehlo/issues/8

Informally, this operation does the same thing as SliceOp except that start_indices , limit_indices and strides are specified dynamically: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#slice

उदाहरण:

%result = mhlo.real_dynamic_slice %operand,
            %start_indices, %limit_indices, %strides
       : (tensor<256x?xf32>, tensor<2xindex>, tensor<2xindex>, tensor<2xindex>) -> tensor<256x?xf32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
`start_indices`	1D tensor of index or 2/4/8/16/32/64-bit integer values
`limit_indices`	1D tensor of index or 2/4/8/16/32/64-bit integer values
`strides`	1D tensor of index or 2/4/8/16/32/64-bit integer values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

`mhlo.recv` (mhlo::RecvOp)

Recv operation

Receives data from a channel with channel_id and produces results .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#recv

उदाहरण:

%results:2 = "mhlo.recv"(%token) {
  // channel_id = 5 : i64,
  // channel_type = #stablehlo<channel_type DEVICE_TO_DEVICE>,
  channel_handle = #mhlo.channel_handle<handle = 5, type = 1>,
  is_host_transfer = false,
  source_target_pairs = dense<[[0, 1], [1, 2]]> : tensor<2x2xi64>
} : (!mhlo.token) -> (tensor<3x4xi32>, !mhlo.token)

गुण:

गुण	MLIR Type	विवरण
`channel_handle`	::mlir::mhlo::ChannelHandleAttr	two 64-bit integers 'handle' and 'type'
`is_host_transfer`	::mlir::BoolAttr	bool attribute
`source_target_pairs`	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

ऑपरेंड:

ओपेरंड	विवरण
`token`	टोकन

परिणाम:

परिणाम

विवरण

«unnamed»

`mhlo.reduce` (mhlo::ReduceOp)

Reduce operation

Applies a reduction function body to inputs and init_values along the dimensions and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#reduce

उदाहरण:

%result = "mhlo.reduce"(%input, %init_value) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.add"(%arg0, %arg1) : (tensor<i32>, tensor<i32>) -> tensor<i32>
    "mhlo.return"(%0) : (tensor<i32>) -> ()
}) {
  dimensions = dense<1> : tensor<1xi64>
} : (tensor<1x6xi32>, tensor<i32>) -> tensor<1xi32>

Traits: InferTensorType , RecursiveMemoryEffects , SameVariadicOperandSize , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

गुण:

गुण	MLIR Type	विवरण
`dimensions`	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

ऑपरेंड:

ओपेरंड	विवरण
`inputs`	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
`init_values`	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

परिणाम:

परिणाम	विवरण
«unnamed»	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

`mhlo.reduce_precision` (mhlo::ReducePrecisionOp)

ReducePrecision operation

वाक्यविन्यास:

operation ::= `mhlo.reduce_precision` $operand `,` `format` `=` custom<ExponentMantissa>($exponent_bits, $mantissa_bits)
              attr-dict `:` custom<SameOperandsAndResultType>(type($operand), type($output))

Performs element-wise conversion of operand to another floating-point type that uses exponent_bits and mantissa_bits and back to the original floating-point type and produces an output tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#reduce_precision

उदाहरण:

%output = mhlo.reduce_precision %operand, format = e5m2 : tensor<6xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

गुण:

गुण	MLIR Type	विवरण
`exponent_bits`	::mlir::IntegerAttr	32-bit signless integer attribute whose value is positive
`mantissa_bits`	::mlir::IntegerAttr	32-bit signless integer attribute whose value is non-negative

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 4/6/8/16/32/64-bit float values

परिणाम:

परिणाम	विवरण
`output`	ranked tensor of 4/6/8/16/32/64-bit float values

`mhlo.reduce_scatter` (mhlo::ReduceScatterOp)

ReduceScatter operation

Within each process group in the process grid, performs reduction, using computations , over the values of the operand tensor from each process, splits the reduction result along scatter_dimension into parts, and scatters the split parts between the processes to produce the result .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#reduce_scatter

उदाहरण:

%result = "mhlo.reduce_scatter"(%operand) ({
  ^bb0(%arg0: tensor<f32>, %arg1: tensor<f32>):
  %0 = mhlo.add %arg0, %arg1 : tensor<f32>
  mhlo.return %0 : tensor<f32>
}) {
  scatter_dimension = 1 : i64,
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>,
  // channel_id = 0
  channel_handle = #mhlo.channel_handle<handle = 0, type = 0>
  // use_global_device_ids = false
} : (tensor<2x4xf32>) -> tensor<2x2xf32>

गुण:

गुण	MLIR Type	विवरण
`scatter_dimension`	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative
`replica_groups`	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
`channel_handle`	::mlir::mhlo::ChannelHandleAttr	two 64-bit integers 'handle' and 'type'
`use_global_device_ids`	::mlir::UnitAttr	unit attribute

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

परिणाम:

परिणाम	विवरण
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

`mhlo.reduce_window` (mhlo::ReduceWindowOp)

ReduceWindow operation

Applies a reduction function body to windows of inputs and init_values and produces results .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#reduce_window

उदाहरण:

%result = "mhlo.reduce_window"(%input, %init_value) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = mhlo.add %arg0, %arg1 : tensor<i32>
    mhlo.return %0 : tensor<i32>
}) {
  window_dimensions = dense<[2, 1]> : tensor<2xi64>,
  window_strides = dense<[4, 1]> : tensor<2xi64>,
  base_dilations = dense<[2, 1]> : tensor<2xi64>,
  window_dilations = dense<[3, 1]> : tensor<2xi64>,
  padding = dense<[[2, 1], [0, 0]]> : tensor<2x2xi64>
} : (tensor<3x2xi32>, tensor<i32>) -> tensor<2x2xi32>

Traits: InferTensorType , RecursiveMemoryEffects , SameVariadicOperandSize , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

गुण:

गुण	MLIR Type	विवरण
`window_dimensions`	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
`window_strides`	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
`base_dilations`	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
`window_dilations`	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
`padding`	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

ऑपरेंड:

ओपेरंड	विवरण
`inputs`	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
`init_values`	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

परिणाम:

परिणाम	विवरण
«unnamed»	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

`mhlo.remainder` (mhlo::RemOp)

Rem operation

वाक्यविन्यास:

operation ::= `mhlo.remainder` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

Performs element-wise remainder of dividend lhs and divisor rhs tensors and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#remainder

उदाहरण:

%result = mhlo.remainder %lhs, %rhs : tensor<4xi64>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`lhs`	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
`rhs`	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

`mhlo.replica_id` (mhlo::ReplicaIdOp)

ReplicaId operation

वाक्यविन्यास:

operation ::= `mhlo.replica_id` attr-dict `:` type(results)

Produces replica_id of the current process.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#replica_id

उदाहरण:

%result = mhlo.replica_id : tensor<ui32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

परिणाम:

परिणाम	विवरण
«unnamed»	ranked tensor of 32-bit unsigned integer values

`mhlo.reshape` (mhlo::ReshapeOp)

Reshape operation

वाक्यविन्यास:

operation ::= `mhlo.reshape` operands attr-dict `:` functional-type(operands, results)

Performs reshape of operand tensor to a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#reshape

उदाहरण:

%result = mhlo.reshape %operand : (tensor<2xf32>) -> tensor<1x2xf32>

Traits: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`operand`	tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

परिणाम:

परिणाम	विवरण
«unnamed»	statically shaped or single bounded dimension tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

`mhlo.return` (mhlo::ReturnOp)

_This operation is a work in progress, so it is not yet included in the specification: https://github.com/openxla/stablehlo/issues/425

Informally, this operation serves as a terminator for regions defined by
the StableHLO ops. Non-StableHLO ops, e.g. `func.func`, have their own
terminators, e.g. `func.return`.

Example:

    ```mlir
    %result = "mhlo.reduce"(%input, %init_value) ({
      ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
        %0 = "mhlo.add"(%arg0, %arg1) : (tensor<i32>, tensor<i32>) -> tensor<i32>
        "mhlo.return"(%0) : (tensor<i32>) -> ()
    }) {
      dimensions = dense<1> : tensor<1xi64>
    } : (tensor<1x6xi32>, tensor<i32>) -> tensor<1xi32>
    ```_

Syntax:

```

operation ::= mhlo.return $results attr-dict ( : type($results)^)?


Traits: `AlwaysSpeculatableImplTrait`, `Terminator`

Interfaces: `ConditionallySpeculatable`, `NoMemoryEffect (MemoryEffectOpInterface)`

Effects: `MemoryEffects::Effect{}`

#### Operands:

| Operand | Description |
| :-----: | ----------- |
| `results` | variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token or nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values |



### `mhlo.reverse` (mhlo::ReverseOp)

_Reverse operation_

Reverses the order of elements in the `operand` along the specified
`dimensions` and produces a `result` tensor.

See:
<a href="https://github.com/openxla/stablehlo/blob/main/docs/spec.md#reverse">https://github.com/openxla/stablehlo/blob/main/docs/spec.md#reverse</a>

Example:
```mlir
%result = mhlo.reverse %operand, dims = [1] : tensor<3x2xi32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

गुण:

गुण	MLIR Type	विवरण
`dimensions`	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

परिणाम:

परिणाम	विवरण
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

`mhlo.rng` (mhlo::RngOp)

Rng operation

Generates random numbers using the rng_distribution algorithm and produces a result tensor of a given shape shape .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#rng

उदाहरण:

%result = mhlo.rng %a, %b, %shape, distribution = NORMAL : (tensor<i32>, tensor<i32>, tensor<2xi64>) -> tensor<3x3xi32>

Traits: InferTensorType

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

गुण:

गुण	MLIR Type	विवरण
`rng_distribution`	::mlir::mhlo::RngDistributionAttr	XLA PRNG distribution to be used.

ऑपरेंड:

ओपेरंड	विवरण
`a`	0D tensor of bool or 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values
`b`	0D tensor of bool or 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values
`shape`	1D tensor of index or 2/4/8/16/32/64-bit integer values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of bool or 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values

`mhlo.rng_bit_generator` (mhlo::RngBitGeneratorOp)

RngBitGenerator operation

Returns an output filled with uniform random data and an updated output state output_state given an initial state initial_state using the pseudorandom number generator algorithm rng_algorithm .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#rng_bit_generator

उदाहरण:

%output_state, %output = mhlo.rng_bit_generator %initial_state, algorithm = THREE_FRY : (tensor<2xui64>) -> (tensor<2xui64>, tensor<2x2xui64>)

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

गुण:

गुण	MLIR Type	विवरण
`rng_algorithm`	::mlir::mhlo::RngAlgorithmAttr	XLA PRNG algorithm to be used.

ऑपरेंड:

ओपेरंड	विवरण
`initial_state`	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values

परिणाम:

परिणाम	विवरण
`output_state`	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values
`output`	statically shaped tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float values

`mhlo.round_nearest_afz` (mhlo::RoundOp)

Round operation

वाक्यविन्यास:

operation ::= `mhlo.round_nearest_afz` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise rounding towards the nearest integer, breaking ties away from zero, on the operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#round_nearest_afz

उदाहरण:

%result = mhlo.round_nearest_afz %operand : tensor<5xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 4/6/8/16/32/64-bit float values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 4/6/8/16/32/64-bit float values

`mhlo.round_nearest_even` (mhlo::RoundNearestEvenOp)

RoundNearestEven operation

वाक्यविन्यास:

operation ::= `mhlo.round_nearest_even` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise rounding towards the nearest integer, breaking ties towards the even integer, on the operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#round_nearest_even

उदाहरण:

%result = mhlo.round_nearest_even %operand : tensor<5xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 4/6/8/16/32/64-bit float values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 4/6/8/16/32/64-bit float values

`mhlo.rsqrt` (mhlo::RsqrtOp)

Rsqrt operation

वाक्यविन्यास:

operation ::= `mhlo.rsqrt` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise reciprocal square root operation on operand tensor and produces a result tensor, implementing the rSqrt operation from the IEEE-754 specification.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#rsqrt

उदाहरण:

%result = mhlo.rsqrt %operand : tensor<2x2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

गुण:

गुण	MLIR Type	विवरण
`result_accuracy`	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

`mhlo.scatter` (mhlo::ScatterOp)

Scatter operation

Produces results tensors which are equal to inputs tensors except that several slices specified by scatter_indices are updated with the values updates using update_computation .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#scatter

उदाहरण:

%result = "mhlo.scatter"(%input, %scatter_indices, %update) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = mhlo.add %arg0, %arg1 : tensor<i32>
    mhlo.return %0 : tensor<i32>
}) {
  scatter_dimension_numbers = #mhlo.scatter<
    update_window_dims = [3, 4],
    inserted_window_dims = [1],
    input_batching_dims = [0],
    scatter_indices_batching_dims = [1],
    scatter_dims_to_operand_dims = [2, 1],
    index_vector_dim = 3>,
  indices_are_sorted = false,
  unique_indices = false
} : (tensor<2x3x4x2xi64>, tensor<2x2x3x2xi64>, tensor<2x2x3x2x2xi64>) -> tensor<2x3x4x2xi64>

Traits: RecursiveMemoryEffects , SameVariadicOperandSize

Interfaces: InferTypeOpInterface

गुण:

गुण	MLIR Type	विवरण
`scatter_dimension_numbers`	::mlir::mhlo::ScatterDimensionNumbersAttr	Attribute that models the dimension information for scatter
`indices_are_sorted`	::mlir::BoolAttr	bool attribute
`unique_indices`	::mlir::BoolAttr	bool attribute

ऑपरेंड:

ओपेरंड	विवरण
`inputs`	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
`scatter_indices`	ranked tensor of integer or index values
`updates`	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

परिणाम:

परिणाम	विवरण
«unnamed»	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

`mhlo.select` (mhlo::SelectOp)

Select operation

वाक्यविन्यास:

operation ::= `mhlo.select` operands attr-dict `:`
              custom<SelectOpType>(type($pred), type($on_true), type($on_false), type($result))

Produces a result tensor where each element is selected from on_true or on_false tensor based on the value of the corresponding element of pred .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#select

उदाहरण:

%result = mhlo.select %pred, %on_true, %on_false : tensor<2x2xi1>, tensor<2x2xi32>

Traits: AlwaysSpeculatableImplTrait , HLO_BroadcastingElementwise , InferTensorType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`pred`	ranked tensor of bool values
`on_true`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
`on_false`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

`mhlo.select_and_scatter` (mhlo::SelectAndScatterOp)

SelectAndScatter operation

Scatters the values from the source tensor using scatter based on the outcome of reduce_window of the input tensor using select and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#select_and_scatter

उदाहरण:

%result = "mhlo.select_and_scatter"(%operand, %source, %init_value) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.compare"(%arg0, %arg1) {
      comparison_direction = #stablehlo<comparison_direction GE>
    } : (tensor<i32>, tensor<i32>) -> tensor<i1>
    "mhlo.return"(%0) : (tensor<i1>) -> ()
}, {
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.add"(%arg0, %arg1) : (tensor<i32>, tensor<i32>) -> tensor<i32>
    "mhlo.return"(%0) : (tensor<i32>) -> ()
}) {
  window_dimensions = dense<[3, 1]> : tensor<2xi64>,
  window_strides = dense<[2, 1]> : tensor<2xi64>,
  padding = dense<[[0, 1], [0, 0]]> : tensor<2x2xi64>
} : (tensor<4x2xi32>, tensor<2x2xi32>, tensor<i32>) -> tensor<4x2xi32>

Traits: RecursiveMemoryEffects

Interfaces: InferTypeOpInterface

गुण:

गुण	MLIR Type	विवरण
`window_dimensions`	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
`window_strides`	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
`padding`	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
`source`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
`init_value`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

परिणाम:

परिणाम	विवरण
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

`mhlo.send` (mhlo::SendOp)

Send operation

Sends inputs to a channel channel_id and produces a result token.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#send

उदाहरण:

%result = "mhlo.send"(%operand, %token) {
  // channel_id = 5 : i64,
  // channel_type = #stablehlo<channel_type DEVICE_TO_DEVICE>,
  channel_handle = #mhlo.channel_handle<handle = 5, type = 1>,
  is_host_transfer = false,
  source_target_pairs = dense<[[0, 1], [1, 2]]> : tensor<2x2xi64>
} : (tensor<3x4xi32>, !mhlo.token) -> !mhlo.token

Interfaces: InferTypeOpInterface

गुण:

गुण	MLIR Type	विवरण
`channel_handle`	::mlir::mhlo::ChannelHandleAttr	two 64-bit integers 'handle' and 'type'
`is_host_transfer`	::mlir::BoolAttr	bool attribute
`source_target_pairs`	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

ऑपरेंड:

ओपेरंड	विवरण
`inputs`	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
`token`	टोकन

परिणाम:

परिणाम	विवरण
«unnamed»	टोकन

`mhlo.set_dimension_size` (mhlo::SetDimensionSizeOp)

SetDimensionSize operation

This operation is a work in progress, so it is not yet included in the specification: https://github.com/openxla/stablehlo/issues/8

Informally, this operation does the same thing as XLA's SetDimensionSize: https://www.tensorflow.org/xla/operation_semantics#setdimensionsize

उदाहरण:

%0 = mhlo.set_dimension_size %arg0, %arg1, dim = 1 : (tensor<4x2xf32>, tensor<i32>) -> tensor<4x2xf32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

गुण:

गुण	MLIR Type	विवरण
`dimension`	::mlir::IntegerAttr	64-bit signless integer attribute whose value is non-negative

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
`size`	tensor of 32-bit signless integer values

परिणाम:

परिणाम	विवरण
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

`mhlo.shift_left` (mhlo::ShiftLeftOp)

ShiftLeft operation

वाक्यविन्यास:

operation ::= `mhlo.shift_left` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

Performs element-wise left-shift operation on the lhs tensor by rhs number of bits and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#shift_left

उदाहरण:

%result = mhlo.shift_left %lhs, %rhs : tensor<6xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`lhs`	ranked tensor of 2/4/8/16/32/64-bit integer values
`rhs`	ranked tensor of 2/4/8/16/32/64-bit integer values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 2/4/8/16/32/64-bit integer values

`mhlo.shift_right_arithmetic` (mhlo::ShiftRightArithmeticOp)

ShiftRightArithmetic operation

वाक्यविन्यास:

operation ::= `mhlo.shift_right_arithmetic` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

Performs element-wise arithmetic right-shift operation on the lhs tensor by rhs number of bits and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#shift_right_arithmetic

उदाहरण:

%result = mhlo.shift_right_arithmetic %lhs, %rhs : tensor<6xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`lhs`	ranked tensor of 2/4/8/16/32/64-bit integer values
`rhs`	ranked tensor of 2/4/8/16/32/64-bit integer values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 2/4/8/16/32/64-bit integer values

`mhlo.shift_right_logical` (mhlo::ShiftRightLogicalOp)

ShiftRightLogical operation

वाक्यविन्यास:

operation ::= `mhlo.shift_right_logical` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

Performs element-wise logical right-shift operation on the lhs tensor by rhs number of bits and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#shift_right_logical

उदाहरण:

%result = mhlo.shift_right_logical %lhs, %rhs : tensor<6xi8>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`lhs`	ranked tensor of 2/4/8/16/32/64-bit integer values
`rhs`	ranked tensor of 2/4/8/16/32/64-bit integer values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 2/4/8/16/32/64-bit integer values

`mhlo.sign` (mhlo::SignOp)

Sign operation

वाक्यविन्यास:

operation ::= `mhlo.sign` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Returns the sign of the operand element-wise and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#sign

उदाहरण:

%result = mhlo.sign %operand : tensor<7xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 2/4/8/16/32/64-bit signless integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 2/4/8/16/32/64-bit signless integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

`mhlo.sine` (mhlo::SineOp)

Sine operation

वाक्यविन्यास:

operation ::= `mhlo.sine` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise sine operation on operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#sine

उदाहरण:

%result = mhlo.sine %operand : tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

गुण:

गुण	MLIR Type	विवरण
`result_accuracy`	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

`mhlo.sinh` (mhlo::SinhOp)

Sinh operation

वाक्यविन्यास:

operation ::= `mhlo.sinh` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise sinh operation on operand tensor and produces a result tensor.

उदाहरण:

%result = mhlo.sinh %operand : tensor<2x2xf32>

Traits: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

ऑपरेंड:

ओपेरंड	विवरण
`operand`	tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

परिणाम:

परिणाम	विवरण
`result`	tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

`mhlo.slice` (mhlo::SliceOp)

Slice operation

Extracts a slice from the operand using statically-computed starting indices and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#slice

उदाहरण:

%result = "mhlo.slice" (%operand) {
  start_indices = dense<[1, 2]> : tensor<2xi64>,
  limit_indices = dense<[3, 4]> : tensor<2xi64>,
  strides = dense<1> : tensor<2xi64>
} : (tensor<3x4xi64>) -> tensor<2x2xi64>

Traits: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

गुण:

गुण	MLIR Type	विवरण
`start_indices`	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
`limit_indices`	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute
`strides`	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

परिणाम:

परिणाम	विवरण
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

`mhlo.sort` (mhlo::SortOp)

Sort operation

Sorts a variadic number of tensors in inputs together, according to a custom comparator , along the given dimension and produces a variadic number of tensors as results .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#sort

उदाहरण:

%result0, %result1 = "mhlo.sort"(%input0, %input1) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>, %arg2: tensor<i32>, %arg3: tensor<i32>):
    %predicate = "mhlo.compare"(%arg0, %arg1) {
      comparison_direction = #stablehlo<comparison_direction GT>
      } : (tensor<i32>, tensor<i32>) -> tensor<i1>
    "mhlo.return"(%predicate) : (tensor<i1>) -> ()
}) {
  dimension = 0 : i64,
  is_stable = true
} : (tensor<2x3xi32>, tensor<2x3xi32>) -> (tensor<2x3xi32>, tensor<2x3xi32>)

Traits: InferTensorType , RecursiveMemoryEffects , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

गुण:

गुण	MLIR Type	विवरण
`dimension`	::mlir::IntegerAttr	64-bit signless integer attribute
`is_stable`	::mlir::BoolAttr	bool attribute

ऑपरेंड:

ओपेरंड	विवरण
`inputs`	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

परिणाम:

परिणाम	विवरण
«unnamed»	variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

`mhlo.sqrt` (mhlo::SqrtOp)

Sqrt operation

वाक्यविन्यास:

operation ::= `mhlo.sqrt` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise square root operation on operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#sqrt

उदाहरण:

%result = mhlo.sqrt %operand : tensor<2x2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

गुण:

गुण	MLIR Type	विवरण
`result_accuracy`	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

`mhlo.stochastic_convert` (mhlo::StochasticConvertOp)

StochasticConvert operation

This operation is a work in progress, so it is not yet included in the specification: https://github.com/openxla/stablehlo/issues/295

Informally, this operation performs element-wise conversion of values from a bigger type to a smaller one with stochastic rounding using the random number passed in.

Traits: AlwaysSpeculatableImplTrait , Elementwise

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 4/6/8/16/32/64-bit float values
`random`	ranked tensor of 2/4/8/16/32/64-bit unsigned integer values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

`mhlo.subtract` (mhlo::SubtractOp)

Subtract operation

वाक्यविन्यास:

operation ::= `mhlo.subtract` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

Performs element-wise subtraction of two tensors lhs and rhs and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#subtract

उदाहरण:

%result = mhlo.subtract %lhs, %rhs : tensor<2xi32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`lhs`	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
`rhs`	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 2/4/8/16/32/64-bit integer or 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

`mhlo.tan` (mhlo::TanOp)

Tan operation

वाक्यविन्यास:

operation ::= `mhlo.tan` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

This operation is a work in progress, so it is not yet included in the specification: https://github.com/openxla/stablehlo/issues/954

Informally, this operation returns Tan(operand) element-wise.

उदाहरण:

%0 = mhlo.tan %arg0 : tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

गुण:

गुण	MLIR Type	विवरण
`result_accuracy`	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

`mhlo.tanh` (mhlo::TanhOp)

Tanh operation

वाक्यविन्यास:

operation ::= `mhlo.tanh` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise hyperbolic tangent operation on operand tensor and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#tanh

उदाहरण:

%result = mhlo.tanh %operand : tensor<2xf32>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

गुण:

गुण	MLIR Type	विवरण
`result_accuracy`	::mlir::mhlo::ResultAccuracyAttr	The requested accuracy for unary ops.

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements or per-tensor integer quantized values

`mhlo.topk` (mhlo::TopKOp)

TopK operation

वाक्यविन्यास:

operation ::= `mhlo.topk` `(`$operand `,` `k` `=` $k (`,` `largest` `=` $largest^)? `)` attr-dict `:`
              type($operand) `->` `(`type($values)`,` type($indices)`)`

Returns top k values and their indices, along the last dimension of the operand if largest=true or the bottom k values if largest=false .

See: https://www.tensorflow.org/xla/operation_semantics#top-k

उदाहरण:

%values, %indices = mhlo.topk(%operand, k=5, largest=true)
  : tensor<100xf32> -> (tensor<5xf32>, tensor<5xi32>)

Traits: InferTensorType , RecursiveMemoryEffects

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

गुण:

गुण	MLIR Type	विवरण
`k`	::mlir::IntegerAttr	64-bit signless integer attribute
`largest`	::mlir::BoolAttr	bool attribute

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

परिणाम:

परिणाम	विवरण
`values`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
`indices`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

`mhlo.torch_index_select` (mhlo::TorchIndexSelectOp)

TorchIndexSelect operation

This operation is on its way out of StableHLO, so it is not included in the specification: https://github.com/openxla/stablehlo/issues/3

Informally, this operation does the same thing as PyTorch's index_select, augmented with support for batch dimensions: https://pytorch.org/docs/stable/generated/torch.index_select.html

The batch_dims attribute specifies the number of major batch dimensions (0 or more) that act like a multidimensional loop over both the operand and the index.

उदाहरण:

%result = "mhlo.torch_index_select"(%operand, %index) {
  dim = 2 : i64,
  batch_dims = 1 : i64
} : (tensor<8x128x3072x64xf32>, tensor<8x16x1024xi32>) -> tensor<8x128x16x1024x64xf32>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

गुण:

गुण	MLIR Type	विवरण
`dim`	::mlir::IntegerAttr	64-bit signless integer attribute
`batch_dims`	::mlir::IntegerAttr	64-bit signless integer attribute

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values
`index`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

परिणाम:

परिणाम	विवरण
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

`mhlo.trace` (mhlo::TraceOp)

Trace operation

वाक्यविन्यास:

operation ::= `mhlo.trace` $operand `,` $tag attr-dict `:` type($operand)

This operation is on its way out of StableHLO, so it is not included in the specification: https://github.com/openxla/stablehlo/issues/604

It is not used by JAX, PyTorch or TensorFlow, so it looks like we should've classified it as "Private to XLA" and not included it in StableHLO in the first place. With that in mind, its semantics will not be documented here.

उदाहरण:

mhlo.trace %arg0, "In test code." : tensor<5x1x5xi32>

गुण:

गुण	MLIR Type	विवरण
`tag`	::mlir::StringAttr	string attribute

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

`mhlo.transpose` (mhlo::TransposeOp)

Transpose operation

Permutes the dimensions of operand tensor using permutation and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#transpose

उदाहरण:

%0 = mhlo.transpose %arg0, dims = [2, 1, 0] : (tensor<1x2x3xi32>) -> tensor<3x2x1xi32>

Traits: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

गुण:

गुण	MLIR Type	विवरण
`permutation`	::mlir::DenseIntElementsAttr	64-bit signless integer elements attribute

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

परिणाम:

परिणाम	विवरण
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

`mhlo.triangular_solve` (mhlo::TriangularSolveOp)

TriangularSolve operation

Solves batches of systems of linear equations with lower or upper triangular coefficient matrices.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#triangular_solve

उदाहरण:

%result = "mhlo.triangular_solve"(%a, %b) {
  left_side = true,
  lower = true,
  unit_diagonal = false,
  transpose_a = #stablehlo<transpose NO_TRANSPOSE>
} : (tensor<3x3xf32>, tensor<3x3xf32>) -> tensor<3x3xf32>

Traits: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

गुण:

गुण	MLIR Type	विवरण
`left_side`	::mlir::BoolAttr	bool attribute
`lower`	::mlir::BoolAttr	bool attribute
`unit_diagonal`	::mlir::BoolAttr	bool attribute
`transpose_a`	::mlir::mhlo::TransposeAttr	Transpose options

ऑपरेंड:

ओपेरंड	विवरण
`a`	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values
`b`	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

परिणाम:

परिणाम	विवरण
«unnamed»	ranked tensor of 4/6/8/16/32/64-bit float or complex type with 32/64-bit float elements values

`mhlo.tuple` (mhlo::TupleOp)

Tuple operation

वाक्यविन्यास:

operation ::= `mhlo.tuple` $val attr-dict `:` custom<TupleOpType>(type($val), type($result))

Produces a result tuple from values val .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#tuple

उदाहरण:

%result = mhlo.tuple %val0, %val1 : tuple<tensor<2xf32>, tuple<tensor<i32>>>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड विवरण

val variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values or token or nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

परिणाम:

परिणाम विवरण

result nested tuple with any combination of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token values

`mhlo.uniform_dequantize` (mhlo::UniformDequantizeOp)

UniformDequantize operation

वाक्यविन्यास:

operation ::= `mhlo.uniform_dequantize` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise conversion of quantized tensor operand to a floating-point tensor result according to the quantization parameters defined by the operand type.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#uniform_dequantize

उदाहरण:

%result = mhlo.uniform_dequantize %operand : (tensor<16x16x!quant.uniform<i8:f32, 34.0:16>>) -> tensor<16x16xf32>

Traits: AlwaysSpeculatableImplTrait , Elementwise , InferTensorType , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of per-tensor integer quantized or per-axis integer quantized values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 4/6/8/16/32/64-bit float values

`mhlo.uniform_quantize` (mhlo::UniformQuantizeOp)

UniformQuantize operation

वाक्यविन्यास:

operation ::= `mhlo.uniform_quantize` $operand attr-dict
              `:` custom<SameOperandsAndResultType>(type($operand), type($result))

Performs element-wise conversion of floating-point tensor or quantized tensor operand to a quantized tensor result according to the quantization parameters defined by the result type.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#uniform_quantize

उदाहरण:

%result = mhlo.uniform_quantize %operand : (tensor<16x16xf32>) -> tensor<16x16x!quant.uniform<ui8:f32, 34.0:16>>

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`operand`	ranked tensor of 4/6/8/16/32/64-bit float or 2/4/8/16/32-bit uniform quantized signed integer or 2/4/8/16/32-bit uniform quantized per axis signed integer or 2/4/8/16/32-bit uniform quantized unsigned integer or 2/4/8/16/32-bit uniform quantized per axis unsigned integer values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of per-tensor integer quantized or per-axis integer quantized values

`mhlo.while` (mhlo::WhileOp)

While operation

Produces the output from executing body function 0 or more times while the cond function outputs true .

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#while

उदाहरण:

%results0, %results1 = "mhlo.while"(%operand0, %operand1) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.compare"(%arg0, %arg1) {
      comparison_direction = #stablehlo<comparison_direction LT>
    } : (tensor<i32>, tensor<i32>) -> tensor<i1>
    "mhlo.return"(%0) : (tensor<i1>) -> ()
}, {
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "mhlo.add"(%arg0, %constant0) : (tensor<i32>, tensor<i32>) -> tensor<i32>
    "mhlo.return"(%0, %arg1) : (tensor<i32>, tensor<i32>) -> ()
}) : (tensor<i32>, tensor<i32>) -> (tensor<i32>, tensor<i32>)

Traits: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

Interfaces: InferTypeOpInterface , OpAsmOpInterface

ऑपरेंड:

ओपेरंड विवरण

operand variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

परिणाम:

परिणाम

विवरण

«unnamed»

variadic of ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values or ranked tensor of per-axis integer quantized values or token or memref of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized values

`mhlo.xla.rng_get_and_update_state` (mhlo::XlaRngGetAndUpdateStateOp)

XlaRngGetAndUpdateState operation

वाक्यविन्यास:

operation ::= `mhlo.xla.rng_get_and_update_state` attr-dict

This operation is private to the XLA compiler, so it is does not yet have a specification.

Informally, this operation represents the change of the global random number generator state for rng instructions. The global state is incremented by delta and the old state is returned.

The output is currently defined for a single output type. If this changes in the future to support multiple types, lowering to use of a global memref must ensure that a single memref is still used and updated appropriately.

Interfaces: InferTypeOpInterface

गुण:

गुण	MLIR Type	विवरण
`delta`	::mlir::IntegerAttr	64-bit signless integer attribute

परिणाम:

परिणाम	विवरण
«unnamed»	statically shaped tensor of 64-bit unsigned integer values

`mhlo.xor` (mhlo::XorOp)

Xor operation

वाक्यविन्यास:

operation ::= `mhlo.xor` $lhs `,` $rhs attr-dict
              `:` custom<SameOperandsAndResultType>(type($lhs), type($rhs), type($result))

Performs element-wise XOR of two tensors lhs and rhs and produces a result tensor.

See: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#xor

उदाहरण:

%result = mhlo.xor %lhs, %rhs : tensor<2xi32>

Traits: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

ऑपरेंड:

ओपेरंड	विवरण
`lhs`	ranked tensor of bool or 2/4/8/16/32/64-bit integer values
`rhs`	ranked tensor of bool or 2/4/8/16/32/64-bit integer values

परिणाम:

परिणाम	विवरण
`result`	ranked tensor of 4/6/8/16/32/64-bit float or bool or 2/4/8/16/32/64-bit integer or complex type with 32/64-bit float elements or per-tensor integer quantized or per-axis integer quantized values

गुण

ArgResultAliasAttr

Attribute that models the alias relationship of entry function argument

This attribute captures the alias relationship of an MHLO main function argument to one of the results, denoted by resultIndex . The argTupleIndices and resultTupleIndices are used to index into nested tuples in operand and result respectively. If isMustAlias is true then the operand-result pair must alias.

This is meant to be used as an attribute on a function argument in MHLO. For example, in the following code it expresses that %arg1 may alias 0-th result.

func @main(%arg0: tensor<2xf32>, %arg1: tensor<3xf32> {mhlo.result_alias =
    mhlo.result_alias<result_index = [2], ...>}
  ) -> tensor<2xf32>, tensor<3xf32> {
  // function body ...
}

पैरामीटर:

पैरामीटर	C++ type	विवरण
argTupleIndices	`::llvm::ArrayRef<int64_t>`	आयाम
resultIndex	`int64_t`
resultTupleIndices	`::llvm::ArrayRef<int64_t>`	आयाम
isMustAlias	`bool`

ChannelHandleAttr

Two 64-bit integers 'handle' and 'type'

वाक्यविन्यास:

#mhlo.channel_handle<
  int64_t,   # handle
  int64_t   # type
>

पैरामीटर:

पैरामीटर	C++ type	विवरण
सँभालना	`int64_t`
प्रकार	`int64_t`

ComparisonDirectionAttr

Which comparison operation to perform.

वाक्यविन्यास:

#mhlo.comparison_direction<
  ::mlir::mhlo::ComparisonDirection   # value
>

पैरामीटर:

पैरामीटर	C++ type	विवरण
कीमत	`::mlir::mhlo::ComparisonDirection`	an enum of type ComparisonDirection

ComparisonTypeAttr

Which comparison type to use.

वाक्यविन्यास:

#mhlo.comparison_type<
  ::mlir::mhlo::ComparisonType   # value
>

पैरामीटर:

पैरामीटर	C++ type	विवरण
कीमत	`::mlir::mhlo::ComparisonType`	an enum of type ComparisonType

ConvDimensionNumbersAttr

Structure of dimension information for conv op

पैरामीटर:

पैरामीटर	C++ type	विवरण
inputBatchDimension	`int64_t`
inputFeatureDimension	`int64_t`
inputSpatialDimensions	`::llvm::ArrayRef<int64_t>`	आयाम
kernelInputFeatureDimension	`int64_t`
kernelOutputFeatureDimension	`int64_t`
kernelSpatialDimensions	`::llvm::ArrayRef<int64_t>`	आयाम
outputBatchDimension	`int64_t`
outputFeatureDimension	`int64_t`
outputSpatialDimensions	`::llvm::ArrayRef<int64_t>`	आयाम

CrossProgramPrefetchAttr

Argument that is prefetched from another program

वाक्यविन्यास:

#mhlo.cross_program_prefetch<
  int64_t,   # parameter
  ::llvm::ArrayRef<int64_t>,   # indices
  std::optional<int64_t>   # offset
>

This attribute captures an argument that is prefetched from another program. For a given CrossProgramPrefetchAttr , parameter tells us which argument of the main function of the module is prefetched, and indices is a shape index telling us what subshape of that argument is prefetched.

A shape has a subshape iff it is a tuple. In that case, the subshape of the tuple by indices is the shape achieved after indexing by each element of indices in turn. For example, the [1,0] subshape of tuple<tuple<token, token>, tuple<tensor<i32>, token>> is tensor<i32> .

An empty value for indices means the whole shape is prefetched.

उदाहरण के लिए,

module attributes { mhlo.cross_program_prefetch = [ #mhlo.cross_program_prefetch< parameter = 0, indices = [0]> ]} {
  func.func @copy(%arg0 : tuple<tensor<2x3xi32>, tensor<i32>>) -> tuple<tensor<2x3xi32>, tensor<i32>> {
    %0 = "mhlo.copy"(%arg0) {is_cross_program_prefetch}
    return %0 : tuple<tensor<2x3xi32>, tensor<i32>>
  }
  func.func @main(%arg0 : tuple<tensor<2x3xi32>, tensor<i32>>) -> tuple<tensor<2x3xi32>, tensor<i32>> {
    %1 = "mhlo.async_start"(%arg0) {called_computation=@copy}
    %2 = "mhlo.async_done"(%1) {called_computation=@copy}
    return %2 : tuple<tensor<2x3xi32>, tensor<i32>>
  }
}

The parameter = 0 tells us that the async copy of the 0 th parameter is a cross_program_prefetch , while the index of [0] tells us that the 0 th element of the tuple is prefetched while the other element of the tuple is not.

पैरामीटर:

पैरामीटर	C++ type	विवरण
पैरामीटर	`int64_t`
सूचकांक	`::llvm::ArrayRef<int64_t>`	आयाम
ओफ़्सेट	`std::optional<int64_t>`

CustomCallScheduleAttr

Specifies the desired schedule for the custom-call.

वाक्यविन्यास:

#mhlo.custom_call_schedule<
  ::mlir::mhlo::CustomCallSchedule   # value
>

पैरामीटर:

पैरामीटर	C++ type	विवरण
कीमत	`::mlir::mhlo::CustomCallSchedule`	an enum of type CustomCallSchedule

DequantizeModeAttr

_Dequantization mode. Only MIN COMBINED is supported.

वाक्यविन्यास:

#mhlo.dequantize_mode<
  ::mlir::mhlo::DequantizeMode   # value
>

पैरामीटर:

पैरामीटर	C++ type	विवरण
कीमत	`::mlir::mhlo::DequantizeMode`	an enum of type DequantizeMode

DomainKindAttr

Kind of domain metatdata attached to an HLO domain.

वाक्यविन्यास:

#mhlo.kind<
  ::mlir::mhlo::DomainKind   # value
>

पैरामीटर:

पैरामीटर	C++ type	विवरण
कीमत	`::mlir::mhlo::DomainKind`	an enum of type DomainKind

DotAlgorithmAttr

Attribute that models the algorithm constraints to use for computing dot.

वाक्यविन्यास:

#mhlo.dot_algorithm<
  Type,   # lhsPrecisionType
  Type,   # rhsPrecisionType
  Type,   # accumulationType
  int64_t,   # lhsComponentCount
  int64_t,   # rhsComponentCount
  int64_t,   # numPrimitiveOperations
  bool   # allowImpreciseAccumulation
>

पैरामीटर:

पैरामीटर	C++ type	विवरण
lhsPrecisionType	`Type`
rhsPrecisionType	`Type`
accumulationType	`Type`
lhsComponentCount	`int64_t`
rhsComponentCount	`int64_t`
numPrimitiveOperations	`int64_t`
allowImpreciseAccumulation	`bool`

DotDimensionNumbersAttr

Attribute that models the dimension information for dot.

पैरामीटर:

पैरामीटर	C++ type	विवरण
lhsBatchingDimensions	`::llvm::ArrayRef<int64_t>`	आयाम
rhsBatchingDimensions	`::llvm::ArrayRef<int64_t>`	आयाम
lhsContractingDimensions	`::llvm::ArrayRef<int64_t>`	आयाम
rhsContractingDimensions	`::llvm::ArrayRef<int64_t>`	आयाम

FftTypeAttr

XLA fast fourier transform type.

वाक्यविन्यास:

#mhlo.fft_type<
  ::mlir::mhlo::FftType   # value
>

पैरामीटर:

पैरामीटर	C++ type	विवरण
कीमत	`::mlir::mhlo::FftType`	an enum of type FftType

FusionKindAttr

Fusion kind

वाक्यविन्यास:

#mhlo.fusion_kind<
  ::mlir::mhlo::FusionKind   # value
>

पैरामीटर:

पैरामीटर	C++ type	विवरण
कीमत	`::mlir::mhlo::FusionKind`	an enum of type FusionKind

GatherDimensionNumbersAttr

Attribute that models the dimension information for gather

पैरामीटर:

पैरामीटर	C++ type	विवरण
offsetDims	`::llvm::ArrayRef<int64_t>`	आयाम
collapsedSliceDims	`::llvm::ArrayRef<int64_t>`	आयाम
operandBatchingDims	`::llvm::ArrayRef<int64_t>`	आयाम
startIndicesBatchingDims	`::llvm::ArrayRef<int64_t>`	आयाम
startIndexMap	`::llvm::ArrayRef<int64_t>`	आयाम
indexVectorDim	`int64_t`

OutputOperandAliasAttr

Attribute that models the alias relationship of output and operand of a CustomCall op

वाक्यविन्यास:

#mhlo.output_operand_alias<
  ::llvm::ArrayRef<int64_t>,   # outputTupleIndices
  int64_t,   # operandIndex
  ::llvm::ArrayRef<int64_t>   # operandTupleIndices
>

This attribute captures the alias relationship of the output to one of the operands for a CustomCall op, denoted by operand_index . The output_tuple_indices and operand_tuple_indices are used to index into output and operand types. These indices lists are empty if the corresponding types are not tuple types, and can be arbitrarily long in case of arbitrarily nested tuple types.

See https://www.tensorflow.org/xla/aliasing

Example when used as array with in mhlo.custom-call:

%0 = "mhlo.custom_call"(%arg0, %arg1) {
  // other attributes
  output_operand_alias = [
    #mhlo.output_operand_alias<output_tuple_indices = [0],
                               operand_index = 0,
                               operand_tuple_indices = [1]>
  ]
} : (tuple<tensor<1x1xf32>, tensor<2x3xf32>>, tensor<5x5xf32>) -> tuple<tensor<2x3xf32>>

The output and the 0th operand are both tuples. The aliasing shows the
relationship between the 0th element in output tuple with the 1st element in
the 0th operand. And both of them are of the same type: tensor<2x3xf32>.

पैरामीटर:

पैरामीटर	C++ type	विवरण
outputTupleIndices	`::llvm::ArrayRef<int64_t>`	आयाम
operandIndex	`int64_t`
operandTupleIndices	`::llvm::ArrayRef<int64_t>`	आयाम

PrecisionAttr

XLA precision for an operand. Has backend specific meaning.

वाक्यविन्यास:

#mhlo.precision<
  ::mlir::mhlo::Precision   # value
>

पैरामीटर:

पैरामीटर	C++ type	विवरण
कीमत	`::mlir::mhlo::Precision`	an enum of type Precision

RaggedDotDimensionNumbersAttr

Attribute that models the dimension information for ragged dot.

पैरामीटर:

पैरामीटर	C++ type	विवरण
dotDimensionNumbers	`::mlir::mhlo::DotDimensionNumbersAttr`	Attribute that models the dimension information for dot.
lhsRaggedDimensions	`::llvm::ArrayRef<int64_t>`	आयाम
rhsGroupDimensions	`::llvm::ArrayRef<int64_t>`	आयाम

ResultAccuracyAttr

The requested accuracy for unary ops.

पैरामीटर:

पैरामीटर	C++ type	विवरण
एटोल	`APFloat`
आरटीओएल	`APFloat`
ulps	`int64_t`
तरीका	`::mlir::mhlo::ResultAccuracyModeAttr`	XLA result accuracy mode.

ResultAccuracyModeAttr

XLA result accuracy mode.

वाक्यविन्यास:

#mhlo.result_accuracy_mode<
  ::mlir::mhlo::ResultAccuracyMode   # value
>

पैरामीटर:

पैरामीटर	C++ type	विवरण
कीमत	`::mlir::mhlo::ResultAccuracyMode`	an enum of type ResultAccuracyMode

RngAlgorithmAttr

XLA PRNG algorithm to be used.

वाक्यविन्यास:

#mhlo.rng_algorithm<
  ::mlir::mhlo::RngAlgorithm   # value
>

पैरामीटर:

पैरामीटर	C++ type	विवरण
कीमत	`::mlir::mhlo::RngAlgorithm`	an enum of type RngAlgorithm

RngDistributionAttr

XLA PRNG distribution to be used.

वाक्यविन्यास:

#mhlo.rng_distribution<
  ::mlir::mhlo::RngDistribution   # value
>

पैरामीटर:

पैरामीटर	C++ type	विवरण
कीमत	`::mlir::mhlo::RngDistribution`	an enum of type RngDistribution

ScatterDimensionNumbersAttr

Attribute that models the dimension information for scatter

पैरामीटर:

पैरामीटर	C++ type	विवरण
updateWindowDims	`::llvm::ArrayRef<int64_t>`	आयाम
insertedWindowDims	`::llvm::ArrayRef<int64_t>`	आयाम
inputBatchingDims	`::llvm::ArrayRef<int64_t>`	आयाम
scatterIndicesBatchingDims	`::llvm::ArrayRef<int64_t>`	आयाम
scatterDimsToOperandDims	`::llvm::ArrayRef<int64_t>`	आयाम
indexVectorDim	`int64_t`

TransposeAttr

Transpose options

वाक्यविन्यास:

#mhlo.transpose<
  ::mlir::mhlo::Transpose   # value
>

पैरामीटर:

पैरामीटर	C++ type	विवरण
कीमत	`::mlir::mhlo::Transpose`	an enum of type Transpose

TypeExtensionsAttr

Attribute that extends tensor type with MHLO type properties.

वाक्यविन्यास:

#mhlo.type_extensions<
  ::llvm::ArrayRef<int64_t>   # bounds
>

This attribute is used to extend MLIR tensor type with MHLO tensor specific properties. These properties aren't modeled in the MLIR type. This attribute is set in the encoding field of the tensor type.

See HLO_BoundedAttrInterface for documentation for bounds .

पैरामीटर:

पैरामीटर	C++ type	विवरण
सीमा	`::llvm::ArrayRef<int64_t>`

प्रकार

AsyncBundleType

Opaque collection of other types

वाक्यविन्यास:

!mhlo.async_bundle<
  ::llvm::ArrayRef<Type>   # types
>

पैरामीटर:

पैरामीटर	C++ type	विवरण
प्रकार	`::llvm::ArrayRef<Type>`

एनम्स

ComparisonDirection

Which comparison operation to perform.

मामले:

प्रतीक	कीमत	डोरी
eq के	`0`	eq के
पूर्वोत्तर	`1`	पूर्वोत्तर
जीई	`2`	जीई
जीटी	`3`	जीटी
एलई	`4`	एलई
लेफ्टिनेंट	`5`	लेफ्टिनेंट

ComparisonType

Which comparison type to use.

मामले:

प्रतीक	कीमत	डोरी
NOTYPE	`0`	NOTYPE
तैरना	`1`	तैरना
TOTALORDER	`2`	TOTALORDER
हस्ताक्षर	`3`	हस्ताक्षर
अहस्ताक्षरित	`4`	अहस्ताक्षरित

CustomCallApiVersion

Custom call API version

मामले:

प्रतीक	कीमत	डोरी
API_VERSION_UNSPECIFIED	`0`	API_VERSION_UNSPECIFIED
API_VERSION_ORIGINAL	`1`	API_VERSION_ORIGINAL
API_VERSION_STATUS_RETURNING	`2`	API_VERSION_STATUS_RETURNING
API_VERSION_STATUS_RETURNING_UNIFIED	`3`	API_VERSION_STATUS_RETURNING_UNIFIED
API_VERSION_TYPED_FFI	`4`	API_VERSION_TYPED_FFI

CustomCallSchedule

Specifies the desired schedule for the custom-call.

मामले:

प्रतीक	कीमत	डोरी
कोई नहीं	`0`	कोई नहीं
नवीनतम	`1`	नवीनतम
सबसे पहले	`2`	सबसे पहले

DequantizeMode

_Dequantization mode. Only MIN COMBINED is supported.

मामले:

प्रतीक	कीमत	डोरी
MIN_COMBINED	`0`	MIN_COMBINED

DomainKind

Kind of domain metatdata attached to an HLO domain.

मामले:

प्रतीक	कीमत	डोरी
शार्डिंग	`0`	शार्डिंग

FftType

XLA fast fourier transform type.

मामले:

प्रतीक	कीमत	डोरी
एफएफटी	`0`	एफएफटी
आईएफएफटी	`1`	आईएफएफटी
RFFT	`2`	RFFT
IRFFT	`3`	IRFFT

FusionKind

Fusion kind

मामले:

प्रतीक	कीमत	डोरी
kLoop	`0`	kLoop
kInput	`1`	kInput
kOutput	`2`	kOutput
kCustom	`3`	kCustom

शुद्धता

XLA precision for an operand. Has backend specific meaning.

मामले:

प्रतीक	कीमत	डोरी
गलती करना	`0`	गलती करना
उच्च	`1`	उच्च
उच्चतम	`2`	उच्चतम

ResultAccuracyMode

XLA result accuracy mode.

मामले:

प्रतीक	कीमत	डोरी
गलती करना	`0`	गलती करना
उच्चतम	`1`	उच्चतम
सहनशीलता	`2`	सहनशीलता

RngAlgorithm

XLA PRNG algorithm to be used.

मामले:

प्रतीक	कीमत	डोरी
गलती करना	`0`	गलती करना
THREE_FRY	`1`	THREE_FRY
PHILOX	`2`	PHILOX

RngDistribution

XLA PRNG distribution to be used.

मामले:

प्रतीक	कीमत	डोरी
वर्दी	`1`	वर्दी
सामान्य	`2`	सामान्य

खिसकाना

Transpose options

मामले:

प्रतीक	कीमत	डोरी
TRANSPOSE_INVALID	`0`	TRANSPOSE_INVALID
NO_TRANSPOSE	`1`	NO_TRANSPOSE
खिसकाना	`2`	खिसकाना
ADJOINT	`3`	ADJOINT

संचालन

mhlo.abs (mhlo::AbsOp)

ऑपरेंड:

परिणाम:

mhlo.acos (mhlo::AcosOp)

ऑपरेंड:

परिणाम:

mhlo.acosh (mhlo::AcoshOp)

ऑपरेंड:

परिणाम:

mhlo.add (mhlo::AddOp)

ऑपरेंड:

परिणाम:

mhlo.add_dependency (mhlo::AddDependencyOp)

ऑपरेंड:

परिणाम:

mhlo.after_all (mhlo::AfterAllOp)

ऑपरेंड:

परिणाम:

mhlo.all_gather (mhlo::AllGatherOp)

गुण:

ऑपरेंड:

परिणाम:

mhlo.all_reduce (mhlo::AllReduceOp)

गुण:

ऑपरेंड:

परिणाम:

mhlo.all_to_all (mhlo::AllToAllOp)

गुण:

ऑपरेंड:

परिणाम:

mhlo.and (mhlo::AndOp)

ऑपरेंड:

परिणाम:

mhlo.asin (mhlo::AsinOp)

ऑपरेंड:

परिणाम:

mhlo.async_done (mhlo::AsyncDoneOp)

ऑपरेंड:

परिणाम:

mhlo.async_start (mhlo::AsyncStartOp)

गुण:

ऑपरेंड:

परिणाम:

mhlo.async_update (mhlo::AsyncUpdateOp)

ऑपरेंड:

परिणाम:

mhlo.atan2 (mhlo::Atan2Op)

ऑपरेंड:

परिणाम:

mhlo.atanh (mhlo::AtanhOp)

ऑपरेंड:

परिणाम:

mhlo.batch_norm_grad (mhlo::BatchNormGradOp)

गुण:

ऑपरेंड:

परिणाम:

mhlo.batch_norm_inference (mhlo::BatchNormInferenceOp)

गुण:

ऑपरेंड:

परिणाम:

mhlo.batch_norm_training (mhlo::BatchNormTrainingOp)

गुण:

ऑपरेंड:

परिणाम:

mhlo.bitcast (mhlo::BitcastOp)

ऑपरेंड:

परिणाम:

mhlo.bitcast_convert (mhlo::BitcastConvertOp)

ऑपरेंड:

परिणाम:

mhlo.broadcast प्रसारण (mhlo::BroadcastOp)

गुण:

ऑपरेंड:

परिणाम:

mhlo.broadcast_in_dim (mhlo::BroadcastInDimOp)

गुण:

ऑपरेंड:

परिणाम:

mhlo.case (mhlo::CaseOp)

`mhlo.abs` (mhlo::AbsOp)

`mhlo.acos` (mhlo::AcosOp)

`mhlo.acosh` (mhlo::AcoshOp)

`mhlo.add` (mhlo::AddOp)

`mhlo.add_dependency` (mhlo::AddDependencyOp)

`mhlo.after_all` (mhlo::AfterAllOp)

`mhlo.all_gather` (mhlo::AllGatherOp)

`mhlo.all_reduce` (mhlo::AllReduceOp)

`mhlo.all_to_all` (mhlo::AllToAllOp)

`mhlo.and` (mhlo::AndOp)

`mhlo.asin` (mhlo::AsinOp)

`mhlo.async_done` (mhlo::AsyncDoneOp)

`mhlo.async_start` (mhlo::AsyncStartOp)

`mhlo.async_update` (mhlo::AsyncUpdateOp)

`mhlo.atan2` (mhlo::Atan2Op)

`mhlo.atanh` (mhlo::AtanhOp)

`mhlo.batch_norm_grad` (mhlo::BatchNormGradOp)

`mhlo.batch_norm_inference` (mhlo::BatchNormInferenceOp)

`mhlo.batch_norm_training` (mhlo::BatchNormTrainingOp)

`mhlo.bitcast` (mhlo::BitcastOp)

`mhlo.bitcast_convert` (mhlo::BitcastConvertOp)

`mhlo.broadcast` प्रसारण (mhlo::BroadcastOp)

`mhlo.broadcast_in_dim` (mhlo::BroadcastInDimOp)

`mhlo.case` (mhlo::CaseOp)

`mhlo.cbrt` (mhlo::CbrtOp)

`mhlo.ceil` (mhlo::CeilOp)

`mhlo.cholesky` (mhlo::ColeskyOp)

`mhlo.clamp` (mhlo::ClampOp)

`mhlo.collective_broadcast` (mhlo::CollectiveBroadcastOp)

`mhlo.collective_permute` (mhlo::CollectivePermuteOp)

`mhlo.compare` (mhlo::CompareOp)

`mhlo.complex` (mhlo::ComplexOp)

`mhlo.composite` (mhlo::CompositeOp)

`mhlo.concatenate` (एमएचएलओ::कॉन्सेटेनेटऑप)

`mhlo.constant` (mhlo::ConstantOp)

`mhlo.convert` (mhlo::ConvertOp)

`mhlo.convolution` (mhlo::ConvolutionOp)

`mhlo.copy` (mhlo::CopyOp)

`mhlo.cosh` (mhlo::CoshOp)

`mhlo.cosine` (mhlo::CosineOp)

`mhlo.count_leading_zeros` (mhlo::ClzOp)

`mhlo.create_token` (mhlo::CreateTokenOp)

`mhlo.cross-replica-sum` (mhlo::CrossReplicaSumOp)