'मह्लो' बोली

संचालन

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{}

ऑपरेंड:

परिणाम:

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

ऑपरेंड:

परिणाम:

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

ऑपरेंड:

परिणाम:

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{}

ऑपरेंड:

परिणाम:

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{}

ऑपरेंड:

परिणाम:

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{}

ऑपरेंड:

परिणाम:

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

गुण:

ऑपरेंड:

परिणाम:

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

गुण:

ऑपरेंड:

परिणाम:

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{}

गुण:

ऑपरेंड:

परिणाम:

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{}

ऑपरेंड:

परिणाम:

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

ऑपरेंड:

परिणाम:

mhlo.asinh (mhlo::AsinhOp)

असिंह ऑपरेशन

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

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

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

उदाहरण:

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

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

इंटरफेस: InferShapedTypeOpInterface , InferTypeOpInterface

ऑपरेंड:

परिणाम:

mhlo.async_done (mhlo::AsyncDoneOp)

AsyncDone ऑपरेशन

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

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

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

इंटरफेस: InferTypeOpInterface

ऑपरेंड:

परिणाम:

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" कहा जाता है। सभी थ्रेड्स के नाम होते हैं।

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

गुण:

ऑपरेंड:

परिणाम:

mhlo.async_update (mhlo::AsyncUpdateOp)

AsyncUpdate ऑपरेशन

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

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

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

इंटरफेस: InferTypeOpInterface

ऑपरेंड:

परिणाम:

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{}

ऑपरेंड:

परिणाम:

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

ऑपरेंड:

परिणाम:

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{}

गुण:

ऑपरेंड:

परिणाम:

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{}

गुण:

ऑपरेंड:

परिणाम:

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{}

गुण:

ऑपरेंड:

परिणाम:

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{}

ऑपरेंड:

परिणाम:

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{}

ऑपरेंड:

परिणाम:

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{}

गुण:

ऑपरेंड:

परिणाम:

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{}

गुण:

ऑपरेंड:

परिणाम:

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

ऑपरेंड:

परिणाम:

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{}

गुण:

ऑपरेंड:

परिणाम:

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{}

ऑपरेंड:

परिणाम:

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{}

गुण:

ऑपरेंड:

परिणाम:

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{}

ऑपरेंड:

परिणाम:

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

गुण:

ऑपरेंड:

परिणाम:

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{}

गुण:

ऑपरेंड:

परिणाम:

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{}

गुण:

ऑपरेंड:

परिणाम:

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{}

ऑपरेंड:

परिणाम:

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

गुण:

ऑपरेंड:

परिणाम:

mhlo.concatenate (mhlo::ConcatenateOp)

संयोजन ऑपरेशन

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

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

उदाहरण:

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

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

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

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

गुण:

ऑपरेंड:

परिणाम:

mhlo.constant (mhlo::ConstantOp)

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

Produces an output tensor from a constant value .

See: 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>

Traits: AlwaysSpeculatableImplTrait , ConstantLike

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

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

गुण:

परिणाम:

mhlo.convert (mhlo::ConvertOp)

Convert operation

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

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

Performs an element-wise conversion from one element type to another on operand tensor and produces a result tensor.

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

उदाहरण:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

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

ऑपरेंड:

परिणाम:

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)

Computes dot products between windows of lhs and slices of rhs and produces result .

See: 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

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

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

गुण:

ऑपरेंड:

परिणाम:

mhlo.copy (mhlo::CopyOp)

Copy operation

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

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

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

Informally, this operation a copy of operand . Depending on the metadata attached to the operation, it can behave quite differently from a no-op.

उदाहरण:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise

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

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

गुण:

ऑपरेंड:

परिणाम:

mhlo.cosh (mhlo::CoshOp)

Cosh operation

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

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

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

उदाहरण:

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

Traits: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

ऑपरेंड:

परिणाम:

mhlo.cosine (mhlo::CosineOp)

Cosine operation

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

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

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

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

उदाहरण:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

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

गुण:

ऑपरेंड:

परिणाम:

mhlo.count_leading_zeros (mhlo::ClzOp)

Clz operation

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

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

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

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

उदाहरण:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

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

ऑपरेंड:

परिणाम:

mhlo.create_token (mhlo::CreateTokenOp)

CreateToken operation

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

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

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 AfterAllOp with 0 inputs: 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{}

परिणाम:

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

CrossReplicaSum 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 AllReduceOp with channel_id = 0 , use_global_device_ids = false and computation implementing addition: 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>

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

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

गुण:

ऑपरेंड:

परिणाम:

mhlo.custom_call (mhlo::CustomCallOp)

CustomCall operation

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

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

Encapsulates an implementation-defined operation call_target_name that takes inputs and called_computations and produces results .

See: 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

गुण:

ऑपरेंड:

परिणाम:

mhlo.divide (mhlo::DivOp)

Div operation

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

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

Performs element-wise division of dividend lhs and divisor rhs tensors and produces a result tensor.

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

उदाहरण:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

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

ऑपरेंड:

परिणाम:

mhlo.domain (mhlo::DomainOp)

Domain operation

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

Informally, these operations are used to group instructions with the same DomainMetadata property. ShardingMetadata is the main use case today to group instructions on the same device. Domain instructions provide two major benefits:

• Prevent unintentionally optimizing instructions across domains.
• Automatically assign the metadata of the instructions created in the domain. Without domain instructions, each HLO optimization pass would have to check and propagate the metadata, which would be easy to miss and also adds complexity to the compiler. Since domain instructions connect two different domains, each domain instruction is associated with two DomainMetadata -- one on the operand side and one on the user side of the domain.

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

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

गुण:

ऑपरेंड:

परिणाम:

mhlo.dot (mhlo::DotOp)

Dot 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 XLA's Dot: https://www.tensorflow.org/xla/operation_semantics#dot

उदाहरण:

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

लक्षण: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

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

गुण:

ऑपरेंड:

परिणाम:

mhlo.dot_general (mhlo::DotGeneralOp)

DotGeneral operation

Computes dot products between slices of lhs and slices of rhs and produces a result tensor.

See: 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

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

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

गुण:

ऑपरेंड:

परिणाम:

mhlo.dynamic_broadcast_in_dim (mhlo::DynamicBroadcastInDimOp)

DynamicBroadcastInDim operation

This operation is functionally identical to broadcast_in_dim op, but the result shape is specified dynamically via output_dimensions .

It also accepts optional attributes to express static knowledge about the expanding behavior of dimensions. If not specified, all dimensions are assumed to be possibly expanding. The sets of dimensions that are known to be expanding and the set of dimensions that are known to be non-expanding must be disjoint and they must be a subset of the operand's dimensions.

See: 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

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

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

गुण:

ऑपरेंड:

परिणाम:

mhlo.dynamic_conv (mhlo::DynamicConvOp)

DynamicConv 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 ConvolutionOp except that padding is specified dynamically via 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

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

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

गुण:

ऑपरेंड:

परिणाम:

mhlo.dynamic_gather (mhlo::DynamicGatherOp)

DynamicGather 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 GatherOp except that slice_sizes are specified dynamically: 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>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

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

गुण:

ऑपरेंड:

परिणाम:

mhlo.dynamic_iota (mhlo::DynamicIotaOp)

DynamicIota operation

This operation is functionally identical to iota op, but the result shape is specified dynamically via output_shape .

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

उदाहरण:

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

लक्षण: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

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

गुण:

ऑपरेंड:

परिणाम:

mhlo.dynamic_pad (mhlo::DynamicPadOp)

DynamicPad operation

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

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

Dynamically Pads the operand , with amount of padding added at low-end/high-end/interior is passed through input tensors.

लक्षण: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

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

ऑपरेंड:

परिणाम:

mhlo.dynamic_reshape (mhlo::DynamicReshapeOp)

DynamicReshape operation

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

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

This operation is functionally identical to reshape op, but the result shape is specified dynamically via output_shape .

See: 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

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

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

ऑपरेंड:

परिणाम:

mhlo.dynamic_slice (mhlo::DynamicSliceOp)

DynamicSlice operation

Extracts a slice from the operand using dynamically-computed starting indices and produces a result tensor.

See: 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>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

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

गुण:

ऑपरेंड:

परिणाम:

mhlo.dynamic_update_slice (mhlo::DynamicUpdateSliceOp)

DynamicUpdateSlice operation

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

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

Produces a result tensor which is equal to the operand tensor except that the slice starting at start_indices is updated with the values in update .

See: 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>

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

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

ऑपरेंड:

परिणाम:

mhlo.einsum (mhlo::EinsumOp)

Einsum 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 TF's 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

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

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

गुण:

ऑपरेंड:

परिणाम:

mhlo.erf (mhlo::ErfOp)

Erf operation

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

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

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

उदाहरण:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

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

ऑपरेंड:

परिणाम:

mhlo.exponential (mhlo::ExpOp)

Exp operation

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

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

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

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

उदाहरण:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

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

गुण:

ऑपरेंड:

परिणाम:

mhlo.exponential_minus_one (mhlo::Expm1Op)

Expm1 operation

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

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

Performs element-wise exponential minus one operation on operand tensor and produces a result tensor.

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

उदाहरण:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

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

गुण:

ऑपरेंड:

परिणाम:

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)

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

गुण:

ऑपरेंड:

परिणाम:

mhlo.floor (mhlo::FloorOp)

फर्श संचालन

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

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)

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

ऑपरेंड:

परिणाम:

mhlo.fusion (mhlo::FusionOp)

संलयन ऑपरेशन

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.

गुण:

ऑपरेंड:

परिणाम:

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)

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

गुण:

ऑपरेंड:

परिणाम:

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)

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

गुण:

ऑपरेंड:

परिणाम:

mhlo.get_tuple_element (mhlo::GetTupleElementOp)

GetTupleElement operation

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

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