'mhlo' উপভাষা

অপারেশন

mhlo.abs (mhlo::AbsOp)

Abs অপারেশন

সিনট্যাক্স:

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

operand টেনসরে উপাদান-ভিত্তিক abs অপারেশন করে এবং 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.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 কম্পাইলারের জন্য ব্যক্তিগত, তাই এটির এখনও কোনো স্পেসিফিকেশন নেই।

অনানুষ্ঠানিকভাবে, এই অপারেশন দুটি অপারেন্ড: একটি ডেটা অপারেন্ড এবং একটি টোকেন। অপারেশনের আউটপুট হল ডেটা অপারেন্ড। আফটারঅল-এর সাথে ব্যবহার করা হলে এই ক্রিয়াকলাপগুলি অ-পার্শ্ব-প্রতিক্রিয়ামূলক ক্রিয়াকলাপগুলিকে অর্ডার করতে সক্ষম করে (যেগুলি টোকেন মান তৈরি করে না)।

উদাহরণ:

%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 প্রয়োগ করে এবং একটি ফলাফল টেনসর তৈরি করে। operands প্রতিটি অপারেন্ডের জন্য computation আলাদাভাবে প্রয়োগ করা হয়, প্রতি অপারেন্ডে একটি ফলাফল তৈরি করে।

দেখুন: 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 অপারেশন

প্রসেস গ্রিডে প্রতিটি প্রসেস গ্রুপের মধ্যে, operand টেনসরের মানগুলিকে split_dimension বরাবর অংশে বিভক্ত করে, প্রসেসের মধ্যে বিভক্ত অংশগুলিকে ছড়িয়ে দেয়, 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.async_done (mhlo::AsyncDoneOp)

AsyncDone অপারেশন

এই অপারেশনটি XLA কম্পাইলারের জন্য ব্যক্তিগত, তাই এটির এখনও কোনো স্পেসিফিকেশন নেই।

অনানুষ্ঠানিকভাবে, এই অপারেশনটি একটি অ্যাসিঙ্ক্রোনাস গণনার শেষ না হওয়া পর্যন্ত ব্লক করে। এটি অ্যাসিঙ্ক্রোনাস গণনার চূড়ান্ত ফলাফল প্রদান করে।

আরও তথ্যের জন্য AsyncStart-এর ডকুমেন্টেশন দেখুন।

ইন্টারফেস: InferTypeOpInterface

অপারেন্ডস:

ফলাফল:

mhlo.async_start (mhlo::AsyncStartOp)

AsyncStart অপারেশন

এই অপারেশনটি XLA কম্পাইলারের জন্য ব্যক্তিগত, তাই এটির এখনও কোনো স্পেসিফিকেশন নেই।

অনানুষ্ঠানিকভাবে, এই অপারেশনটি একটি অ্যাসিঙ্ক্রোনাস গণনা শুরু করে।

এটি ব্যবহার করা হয় যখন এমন ফাংশন থাকে যেখানে অ্যাসিঙ্ক্রোনাস ওয়েট (যেমন DMA) এবং অন-থ্রেড গণনা উভয়ই থাকে। উদাহরণস্বরূপ, একটি ফাংশন একটি গণনা, একটি ডিএমএ, আরেকটি গণনা, একটি দ্বিতীয় ডিএমএ এবং একটি চূড়ান্ত গণনা নিয়ে গঠিত হতে পারে। এটি একটি async_start এর পরে এবং async_update এবং একটি async_done হিসাবে উপস্থাপন করা হবে। async_start প্রথম কম্পিউটেশন অন-থ্রেড করবে এবং তারপর DMA শুরু করবে। async_update DMA সম্পূর্ণ হওয়ার জন্য অপেক্ষা করবে যদি এটি এখনও সম্পন্ন না হয়, তারপর ফাংশনে দ্বিতীয় গণনাটি চালান এবং দ্বিতীয় DMA শুরু করুন। অবশেষে, async_done এই শেষ DMA-তে অপেক্ষা করবে, এবং তারপর শেষ গণনা চালাবে যা অন-থ্রেড চালাতে হবে এবং সেই চূড়ান্ত গণনার ফলাফল ফেরত দেবে।

operands কম্পিউটেশনে সরাসরি পাস করা হয় called_computation একটি ফাংশন যা অ্যাসিঙ্ক্রোনাসভাবে চালানো হবে execution_thread হল সেই থ্রেডের নাম যেখানে এটি চালানো হবে। প্রধান থ্রেডকে "প্রধান" বলা হয়। সব থ্রেডের নাম আছে।

এটি async ops এর মধ্যে প্রয়োজনীয় সমস্ত স্টেট প্রদান করে। বাফার অ্যাসাইনমেন্টের পরে, রিটার্ন মানগুলি ইনপুট, ফলাফল এবং async op দ্বারা প্রয়োজনীয় বা সম্পাদিত যেকোনো স্ক্র্যাচপ্যাড ধরে রাখার জন্য প্রয়োজনীয় স্থান উপস্থাপন করে।

গুণাবলী:

অপারেন্ডস:

ফলাফল:

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 টেনসরে উপাদান-ভিত্তিক atan2 অপারেশন করে এবং 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.batch_norm_grad (mhlo::BatchNormGradOp)

BatchNormGrad অপারেশন

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)

BatchNormInference অপারেশন

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 :: বিটকাস্টপ)

বিটকাস্ট অপারেশন

সিনট্যাক্স:

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

এই অপারেশনটি এক্সএলএ সংকলকের কাছে ব্যক্তিগত, সুতরাং এটির এখনও কোনও স্পেসিফিকেশন নেই।

অনানুষ্ঠানিকভাবে, এই অপারেশনটি উপাদানগুলির শারীরিক বিন্যাসটি যেভাবে অপরিবর্তিত রয়েছে সেভাবে ইনপুটটির আকার পরিবর্তন করে।

"উপাদানগুলির শারীরিক ব্যবস্থা" বোঝার জন্য এই অপারেশনের জন্য বিন্যাসের তথ্য প্রয়োজন, এবং এমএইচএলওতে লেআউট সমর্থন বর্তমানে একটি কাজ চলছে।

উদাহরণ:

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

বৈশিষ্ট্য: AlwaysSpeculatableImplTrait

NoMemoryEffect (MemoryEffectOpInterface) : ConditionallySpeculatable

প্রভাব: MemoryEffects::Effect{}

অপারেন্ডস:

ফলাফল:

mhlo.bitcast_convert (mhlo :: বিটকাস্ট কনভার্টপ)

বিটকাস্ট কনভার্ট অপারেশন

সিনট্যাক্স:

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

operand টেনসরে একটি বিটকাস্ট অপারেশন সম্পাদন করে এবং একটি result টেনসর তৈরি করে যেখানে result টেনসরের ধরন ব্যবহার করে সম্পূর্ণ operand টেনসরের বিটগুলি পুনরায় ব্যাখ্যা করা হয়।

দেখুন: 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 :: ব্রডকাস্টপ)

সম্প্রচার অপারেশন

এই অপারেশনটি স্থিতিশীলতার বাইরে চলে যাচ্ছে, সুতরাং এটি স্পেসিফিকেশনে অন্তর্ভুক্ত নয়: https://github.com/openxla/stablehlo/issues/3

অনানুষ্ঠানিকভাবে, এই অপারেশনটি এক্সএলএর সম্প্রচারের মতো একই কাজ করে: 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 :: ব্রডকাস্ট ইনডিমপ)

ব্রডকাস্টাইন্ডিম অপারেশন

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

NoMemoryEffect (MemoryEffectOpInterface) : ConditionallySpeculatable

প্রভাব: MemoryEffects::Effect{}

গুণাবলী:

অপারেন্ডস:

ফলাফল:

mhlo.case (mhlo :: কেসোপ)

কেস অপারেশন

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>

বৈশিষ্ট্য Elementwise AlwaysSpeculatableImplTrait SameOperandsAndResultShape , CompatibleOperandsAndResultType

ইন্টারফেস: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

প্রভাব: MemoryEffects::Effect{}

অপারেন্ডস:

ফলাফল:

mhlo.ceil (mhlo :: সিলোপ)

সিল অপারেশন

সিনট্যাক্স:

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>

বৈশিষ্ট্য Elementwise AlwaysSpeculatableImplTrait SameOperandsAndResultShape , CompatibleOperandsAndResultType

ইন্টারফেস: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

প্রভাব: MemoryEffects::Effect{}

অপারেন্ডস:

ফলাফল:

mhlo.cholesky (mhlo :: Cololeskyop)

চোলেস্কি অপারেশন

ম্যাট্রিক্সের একটি ব্যাচের চোলেস্কি পচন গণনা করে।

দেখুন: 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 :: ক্ল্যাম্পপ)

ক্ল্যাম্প অপারেশন

সিনট্যাক্স:

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 :: তুলনা)

অপারেশন তুলনা করুন

সিনট্যাক্স:

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 :: কমপ্লেক্সপ)

জটিল অপারেশন

সিনট্যাক্স:

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 SameOperandsElementType , Elementwise , SameOperandsAndResultShape

ইন্টারফেস: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

প্রভাব: MemoryEffects::Effect{}

অপারেন্ডস:

ফলাফল:

mhlo.composite (mhlo :: কমপোজোপপ)

কম্পোজিট অপারেশন

সিনট্যাক্স:

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

কনটেনেট অপারেশন

প্রদত্ত আর্গুমেন্ট হিসাবে একই ক্রমে 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

ইন্টারফেস: ConditionallySpeculatable , InferShapedTypeOpInterface , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

প্রভাব: MemoryEffects::Effect{}

গুণাবলী:

অপারেন্ডস:

ফলাফল:

mhlo.constant (mhlo :: কনস্টান্টপ)

অবিচ্ছিন্ন অপারেশন

একটি ধ্রুবক 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

NoMemoryEffect (MemoryEffectOpInterface) InferTypeOpInterface ConditionallySpeculatable

প্রভাব: MemoryEffects::Effect{}

গুণাবলী:

ফলাফল:

mhlo.convert (mhlo :: কনভার্টপ)

অপারেশন রূপান্তর

সিনট্যাক্স:

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

operand টেনসরে একটি এলিমেন্ট টাইপ থেকে অন্য এলিমেন্ট টাইপ কনভার্সন করে এবং result টেনসর তৈরি করে।

দেখুন: https://github.com/openxla/stablehlo/blob/main/docs/spec.md# কনভার্ট

উদাহরণ:

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

বৈশিষ্ট্য: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

ইন্টারফেস: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

প্রভাব: MemoryEffects::Effect{}

অপারেন্ডস:

ফলাফল:

mhlo.convolution (mhlo :: কনভোলিউশনপ)

কনভোলিউশন অপারেশন

সিনট্যাক্স:

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 তৈরি করে।

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>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

গুণাবলী:

Operands:

ফলাফল:

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)

Effects: MemoryEffects::Effect{}

গুণাবলী:

Operands:

ফলাফল:

mhlo.cosine (mhlo::CosineOp)

Cosine operation

সিনট্যাক্স:

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

operand টেনসরে উপাদান-ভিত্তিক কোসাইন অপারেশন সম্পাদন করে এবং result টেনসর তৈরি করে।

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)

Effects: MemoryEffects::Effect{}

Operands:

ফলাফল:

mhlo.count_leading_zeros (mhlo::ClzOp)

Clz operation

সিনট্যাক্স:

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

operand টেনসরে অগ্রণী শূন্য বিটের সংখ্যার উপাদান-ভিত্তিক গণনা সম্পাদন করে এবং result টেনসর তৈরি করে।

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)

Effects: MemoryEffects::Effect{}

Operands:

ফলাফল:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

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

Effects: MemoryEffects::Effect{}

গুণাবলী:

Operands:

ফলাফল:

mhlo.custom_call (mhlo::CustomCallOp)

CustomCall operation

সিনট্যাক্স:

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

একটি বাস্তবায়ন-সংজ্ঞায়িত অপারেশন call_target_name এনক্যাপসুলেট করে যা inputs নেয় এবং called_computations নেয় এবং 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.

Interfaces: MemoryEffectOpInterface

গুণাবলী:

Operands:

ফলাফল:

mhlo.divide (mhlo::DivOp)

Div operation

সিনট্যাক্স:

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

ডিভিডেন্ড lhs এবং ভাজক rhs টেনসরগুলির উপাদান-ভিত্তিক বিভাজন সম্পাদন করে এবং একটি result টেনসর তৈরি করে।

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)

Effects: MemoryEffects::Effect{}

Operands:

ফলাফল:

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)

Effects: MemoryEffects::Effect{}

গুণাবলী:

Operands:

ফলাফল:

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>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

গুণাবলী:

Operands:

ফলাফল:

mhlo.dot_general (mhlo::DotGeneralOp)

DotGeneral operation

lhs এর স্লাইস এবং rhs এর স্লাইসের মধ্যে ডট পণ্য গণনা করে এবং result টেনসর তৈরি করে।

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>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

গুণাবলী:

Operands:

ফলাফল:

mhlo.dynamic_broadcast_in_dim (mhlo::DynamicBroadcastInDimOp)

DynamicBroadcastInDim operation

এই ক্রিয়াকলাপটি broadcast_in_dim op এর সাথে কার্যকরীভাবে অভিন্ন, তবে ফলাফলের আকারটি output_dimensions মাধ্যমে গতিশীলভাবে নির্দিষ্ট করা হয়েছে।

It also accepts optional attributes to express static knowledge about the expanding behavior of dimensions. নির্দিষ্ট করা না থাকলে, সমস্ত মাত্রা সম্ভবত প্রসারিত হচ্ছে বলে ধরে নেওয়া হয়। 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>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

গুণাবলী:

Operands:

ফলাফল:

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>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

গুণাবলী:

Operands:

ফলাফল:

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)

Effects: MemoryEffects::Effect{}

গুণাবলী:

Operands:

ফলাফল:

mhlo.dynamic_iota (mhlo::DynamicIotaOp)

DynamicIota operation

এই অপারেশনটি আইওটিএ অপের সাথে কার্যত অভিন্ন, তবে ফলাফলের আকারটি 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>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

গুণাবলী:

Operands:

ফলাফল:

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.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

ফলাফল:

mhlo.dynamic_reshape (mhlo::DynamicReshapeOp)

DynamicReshape operation

সিনট্যাক্স:

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

এই অপারেশনটি পুনরায় আকার দেওয়ার জন্য কার্যত অভিন্ন, তবে ফলাফলের আকারটি 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>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

ফলাফল:

mhlo.dynamic_slice (mhlo::DynamicSliceOp)

DynamicSlice operation

গতিশীলভাবে অভিযুক্ত প্রারম্ভিক সূচকগুলি ব্যবহার করে operand থেকে একটি টুকরো বের করে এবং result টেনসর তৈরি করে।

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)

Effects: MemoryEffects::Effect{}

গুণাবলী:

Operands:

ফলাফল:

mhlo.dynamic_update_slice (mhlo::DynamicUpdateSliceOp)

DynamicUpdateSlice operation

সিনট্যাক্স:

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

একটি result টেনসর তৈরি করে যা operand টেনসরের সমান, ব্যতীত start_indices শুরু হওয়া স্লাইসটি 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)

Effects: MemoryEffects::Effect{}

Operands:

ফলাফল:

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>

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

গুণাবলী:

Operands:

ফলাফল:

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.

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

উদাহরণ:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Operands:

ফলাফল:

mhlo.exponential (mhlo::ExpOp)

Exp operation

সিনট্যাক্স:

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

operand টেনসরে উপাদান-ভিত্তিক এক্সফোনেনশিয়াল অপারেশন সম্পাদন করে এবং result টেনসর তৈরি করে।

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)

Effects: MemoryEffects::Effect{}

Operands:

ফলাফল:

mhlo.exponential_minus_one (mhlo::Expm1Op)

Expm1 operation

সিনট্যাক্স:

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

operand টেনসরে উপাদান-ভিত্তিক এক্সফোনেনশিয়াল বিয়োগ একটি অপারেশন সম্পাদন করে এবং result টেনসর তৈরি করে।

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)

Effects: MemoryEffects::Effect{}

Operands:

ফলাফল:

mhlo.fft (mhlo::FftOp)

Fft operation

বাস্তব এবং জটিল ইনপুট/আউটপুটগুলির জন্য ফরোয়ার্ড এবং বিপরীত ফুরিয়ার ট্রান্সফর্মগুলি সম্পাদন করে।

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

গুণাবলী:

Operands:

ফলাফল:

mhlo.floor (mhlo::FloorOp)

Floor operation

সিনট্যাক্স:

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

operand টেনসারের উপাদান-ভিত্তিক তল সম্পাদন করে এবং result টেনসর তৈরি করে।

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

Operands:

ফলাফল:

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.

গুণাবলী:

Operands:

ফলাফল:

mhlo.gather (mhlo::GatherOp)

Gather operation

start_indices নির্দিষ্ট করা অফসেটগুলি থেকে operand টেনসর থেকে স্লাইসগুলি সংগ্রহ করে এবং result টেনসর তৈরি করে।

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

গুণাবলী:

Operands:

ফলাফল:

mhlo.get_dimension_size (mhlo::GetDimensionSizeOp)

GetDimensionSize operation

operand প্রদত্ত dimension আকার উত্পাদন করে।

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

গুণাবলী:

Operands:

ফলাফল:

mhlo.get_tuple_element (mhlo::GetTupleElementOp)

GetTupleElement operation

সিনট্যাক্স:

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

operand টুপলের index অবস্থানে উপাদানটি বের করে এবং একটি 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{}

গুণাবলী:

Operands:

ফলাফল:

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

Operands:

ফলাফল:

mhlo.imag (mhlo::ImagOp)

Imag operation

সিনট্যাক্স:

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

operand থেকে কল্পিত অংশ, উপাদান-ভিত্তিক বের করে এবং result টেনসর তৈরি করে।

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

Operands:

ফলাফল:

mhlo.infeed (mhlo::InfeedOp)

Infeed operation

ইনফিড থেকে ডেটা পড়ে এবং 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)

গুণাবলী:

Operands:

ফলাফল:

mhlo.iota (mhlo::IotaOp)

Iota operation

iota_dimension মাত্রা বরাবর শূন্য থেকে শুরু করে ক্রমবর্ধমান ক্রমের মানগুলির সাথে একটি output টেনসর পূরণ করে।

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

গুণাবলী:

ফলাফল:

mhlo.is_finite (mhlo::IsFiniteOp)

IsFinite operation

সিনট্যাক্স:

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

x এর মানটি সীমাবদ্ধ কিনা তা পরীক্ষা করে দেখুন (অর্থাত্ +আইএনএফ, -ইনফ, না ন্যান) এবং একটি y টেনসর উত্পাদন করে।

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

Operands:

ফলাফল:

mhlo.log (mhlo::LogOp)

Log operation

সিনট্যাক্স:

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

operand টেনসরে উপাদান-ভিত্তিক লোগারিদম অপারেশন সম্পাদন করে এবং result টেনসর তৈরি করে।

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

Operands:

ফলাফল:

mhlo.log_plus_one (mhlo::Log1pOp)

Log1p operation

সিনট্যাক্স:

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

operand টেনসরে উপাদান-ভিত্তিক লোগারিদম প্লাস ওয়ান অপারেশন সম্পাদন করে এবং result টেনসর তৈরি করে।

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

Operands:

ফলাফল:

mhlo.logistic (mhlo::LogisticOp)

Logistic operation

সিনট্যাক্স:

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

operand টেনসরে উপাদান-ভিত্তিক লজিস্টিক অপারেশন সম্পাদন করে এবং result টেনসর তৈরি করে।

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

Operands:

ফলাফল:

mhlo.map (mhlo::MapOp)

Map operation

dimensions বরাবর inputs একটি মানচিত্র ফাংশন computation প্রয়োগ করে এবং result টেনসর তৈরি করে।

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

গুণাবলী:

Operands:

ফলাফল:

mhlo.maximum (mhlo::MaxOp)

Max operation

সিনট্যাক্স:

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

টেনসর lhs এবং rhs উপাদান-ভিত্তিক সর্বোচ্চ অপারেশন সম্পাদন করে এবং result টেনসর তৈরি করে।

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

Operands:

ফলাফল:

mhlo.minimum (mhlo::MinOp)

Min operation

সিনট্যাক্স:

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

টেনসর lhs এবং rhs উপাদান-ভিত্তিক ন্যূনতম অপারেশন সম্পাদন করে এবং result টেনসর তৈরি করে।

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

Operands:

ফলাফল:

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

Operands:

ফলাফল:

mhlo.multiply (mhlo::MulOp)

Mul operation

সিনট্যাক্স:

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

দুটি টেনসর lhs এবং rhs উপাদান-ভিত্তিক পণ্য সম্পাদন করে এবং result টেনসর তৈরি করে।

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

Operands:

ফলাফল:

mhlo.negate (mhlo::NegOp)

Neg operation

সিনট্যাক্স:

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

operand টেনসারের উপাদান-ভিত্তিক অবহেলা সম্পাদন করে এবং result টেনসর তৈরি করে।

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

Operands:

ফলাফল:

mhlo.not (mhlo::NotOp)

Not operation

সিনট্যাক্স:

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

Operands:

ফলাফল:

mhlo.optimization_barrier (mhlo::OptimizationBarrierOp)

OptimizationBarrier operation

সিনট্যাক্স:

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

নিশ্চিত করে যে operand উত্পাদনকারী অপারেশনগুলি result উপর নির্ভর করে এমন কোনও ক্রিয়াকলাপের আগে কার্যকর করা হয় এবং বাধা জুড়ে চলমান অপারেশনগুলি থেকে সংকলক রূপান্তরগুলি প্রতিরোধ করে। তা ছাড়া, অপারেশনটি একটি পরিচয়, অর্থাত্ 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{}

Operands:

ফলাফল:

mhlo.or (mhlo::OrOp)

Or operation

সিনট্যাক্স:

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

উপাদান-ভিত্তিক বা দুটি টেনসর lhs এবং rhs সম্পাদন করে এবং result টেনসর তৈরি করে।

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

Operands:

ফলাফল:

mhlo.outfeed (mhlo::OutfeedOp)

Outfeed operation

আউটপিডে inputs লিখুন এবং result টোকেন তৈরি করে।

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

গুণাবলী:

Operands:

ফলাফল:

mhlo.pad (mhlo::PadOp)

Pad operation

টেনসারের চারপাশে প্যাডিং এবং সেইসাথে প্রদত্ত padding_value সহ টেনসারের উপাদানগুলির মধ্যে operand প্রসারিত করে।

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

গুণাবলী:

Operands:

ফলাফল:

mhlo.partition_id (mhlo::PartitionIdOp)

PartitionId operation

সিনট্যাক্স:

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

বর্তমান প্রক্রিয়াটির partition_id উত্পাদন করে।

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

উদাহরণ:

%result = mhlo.partition_id : tensor<ui32>

Interfaces: InferTypeOpInterface

ফলাফল:

mhlo.popcnt (mhlo::PopulationCountOp)

PopulationCount operation

সিনট্যাক্স:

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

operand টেনসরে সেট করা বিট সংখ্যার উপাদান-ভিত্তিক গণনা সম্পাদন করে এবং result টেনসর তৈরি করে।

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

Operands:

ফলাফল:

mhlo.power (mhlo::PowOp)

Pow operation

সিনট্যাক্স:

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

rhs টেনসর দ্বারা lhs টেনসারের উপাদান-ভিত্তিক এক্সপেনশনেশন সম্পাদন করে এবং result টেনসর তৈরি করে।

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

Operands:

ফলাফল:

mhlo.real (mhlo::RealOp)

Real operation

সিনট্যাক্স:

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

operand থেকে আসল অংশটি, উপাদান-ভিত্তিক নিষ্কাশন করে এবং result টেনসর তৈরি করে।

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

Operands:

ফলাফল:

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

Operands:

ফলাফল:

mhlo.recv (mhlo::RecvOp)

Recv operation

channel_id সহ একটি চ্যানেল থেকে ডেটা গ্রহণ করে এবং 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 HOST_TO_DEVICE>,
  channel_handle = #mhlo.channel_handle<handle = 5, type = 3>,
  is_host_transfer = true
} : (!mhlo.token) -> (tensor<3x4xi32>, !mhlo.token)

গুণাবলী:

Operands:

ফলাফল:

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

গুণাবলী:

Operands:

ফলাফল:

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

operand অন্য ভাসমান-পয়েন্ট টাইপে উপাদান-ভিত্তিক রূপান্তর সম্পাদন করে যা exponent_bits এবং mantissa_bits ব্যবহার করে এবং মূল ভাসমান-পয়েন্ট টাইপে ফিরে আসে এবং একটি output টেনসর তৈরি করে।

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

গুণাবলী:

Operands:

ফলাফল:

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>

গুণাবলী:

Operands:

ফলাফল:

mhlo.reduce_window (mhlo::ReduceWindowOp)

ReduceWindow operation

inputs এবং init_values ​​এর উইন্ডোতে একটি হ্রাস ফাংশন body প্রয়োগ করে এবং 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

গুণাবলী:

Operands:

ফলাফল:

mhlo.remainder (mhlo::RemOp)

Rem operation

সিনট্যাক্স:

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

লভ্যাংশ lhs এবং ডিভাইজার rhs টেনারগুলির উপাদান অনুসারে বাকী অংশগুলি সম্পাদন করে এবং result টেনসর তৈরি করে।

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

Operands:

ফলাফল:

mhlo.replica_id (mhlo::ReplicaIdOp)

ReplicaId operation

সিনট্যাক্স:

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

বর্তমান প্রক্রিয়াটির replica_id উত্পাদন করে।

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

ফলাফল:

mhlo.reshape (mhlo::ReshapeOp)

Reshape operation

সিনট্যাক্স:

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

result টেনসারে operand টেনসর পুনরায় আকার দেয়।

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

Operands:

ফলাফল:

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 f4E2M1FN type or f6E2M3FN type or f6E3M2FN type or f8E3M4 type or f8E4M3 type or f8E4M3FN type or f8E4M3FNUZ type or f8E4M3B11FNUZ type or f8E5M2 type or f8E5M2FNUZ type or f8E8M0FNU type or 16-bit float or 32-bit float or 64-bit float or bfloat16 type or pred (AKA boolean or 1-bit integer) or 2/4/8/16/32/64-bit signless integer or 2/4/8/16/32/64-bit unsigned integer or complex type with 32-bit float or 64-bit float elements or 2/4/8/16/32-bit uniform quantized signed integer or 2/4/8/16/32-bit uniform quantized unsigned integer or 2/4/8/16/32-bit uniform quantized per axis signed integer or 2/4/8/16/32-bit uniform quantized per axis unsigned integer values or token or nested tuple with any combination of ranked tensor of f4E2M1FN type or f6E2M3FN type or f6E3M2FN type or f8E3M4 type or f8E4M3 type or f8E4M3FN type or f8E4M3FNUZ type or f8E4M3B11FNUZ type or f8E5M2 type or f8E5M2FNUZ type or f8E8M0FNU type or 16-bit float or 32-bit float or 64-bit float or bfloat16 type or pred (AKA boolean or 1-bit integer) or 2/4/8/16/32/64-bit signless integer or 2/4/8/16/32/64-bit unsigned integer or complex type with 32-bit float or 64-bit float elements or 2/4/8/16/32-bit uniform quantized signed integer or 2/4/8/16/32-bit uniform quantized unsigned integer values or ranked tensor of 2/4/8/16/32-bit uniform quantized per axis signed integer or 2/4/8/16/32-bit uniform quantized per axis unsigned integer values or token 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{}

গুণাবলী:

Operands:

ফলাফল:

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

গুণাবলী:

Operands:

ফলাফল:

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

গুণাবলী:

Operands:

ফলাফল:

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

Operands:

ফলাফল:

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

Operands:

ফলাফল:

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

Operands:

ফলাফল:

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

গুণাবলী:

Operands:

ফলাফল:

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

Operands:

ফলাফল:

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

গুণাবলী:

Operands:

ফলাফল:

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_HOST>,
  channel_handle = #mhlo.channel_handle<handle = 5, type = 2>,
  is_host_transfer = true
} : (tensor<3x4xi32>, !mhlo.token) -> !mhlo.token

Interfaces: InferTypeOpInterface

গুণাবলী:

Operands:

ফলাফল:

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

গুণাবলী:

Operands:

ফলাফল:

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

Operands:

ফলাফল:

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

Operands:

ফলাফল:

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

Operands:

ফলাফল:

mhlo.sign (mhlo::SignOp)

সাইন অপারেশন

সিনট্যাক্স:

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

Operands:

ফলাফল:

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

Operands:

ফলাফল:

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

গুণাবলী:

Operands:

ফলাফল:

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

গুণাবলী:

Operands:

ফলাফল:

mhlo.sparse_dot (mhlo::SparseDotOp)

Sparse dot operation

Similar to dot_general operation, with one or both of the operands being sparse. An additional argument provides sparsity meta information. Disclaimer: this op is experimental / a work in progress.

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

গুণাবলী:

Operands:

ফলাফল:

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

Operands:

ফলাফল:

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

Operands:

ফলাফল:

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

Operands:

ফলাফল:

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

Operands:

ফলাফল:

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

Operands:

ফলাফল:

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

গুণাবলী:

Operands:

ফলাফল:

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

গুণাবলী:

Operands:

ফলাফল:

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>

গুণাবলী:

Operands:

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

গুণাবলী:

Operands:

ফলাফল:

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

গুণাবলী:

Operands:

ফলাফল:

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

Operands:

ফলাফল:

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

Operands:

ফলাফল:

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

Operands:

ফলাফল:

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

Operands:

ফলাফল:

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

গুণাবলী:

ফলাফল:

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

Operands:

ফলাফল:

গুণাবলী

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

পরামিতি:

ChannelHandleAttr

two 64-bit integers 'handle' and 'type'

সিনট্যাক্স:

#mhlo.channel_handle<
  int64_t,   # handle
  int64_t   # type
>

পরামিতি:

ComparisonDirectionAttr

Which comparison operation to perform.

সিনট্যাক্স:

#mhlo.comparison_direction<
  ::mlir::mhlo::ComparisonDirection   # value
>

Enum cases:

• EQ ( EQ )
• NE ( NE )
• GE ( GE )
• GT ( GT )
• LE ( LE )
• LT ( LT )

পরামিতি:

ComparisonTypeAttr

Which comparison type to use.

সিনট্যাক্স:

#mhlo.comparison_type<
  ::mlir::mhlo::ComparisonType   # value
>

Enum cases:

• NOTYPE ( NOTYPE )
• FLOAT ( FLOAT )
• TOTALORDER ( TOTALORDER )
• SIGNED ( SIGNED )
• UNSIGNED ( UNSIGNED )

পরামিতি:

ConvDimensionNumbersAttr

Structure of dimension information for conv op

পরামিতি:

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.

পরামিতি:

CustomCallScheduleAttr

Specifies the desired schedule for the custom-call.

সিনট্যাক্স:

#mhlo.custom_call_schedule<
  ::mlir::mhlo::CustomCallSchedule   # value
>

Enum cases:

• NONE ( NONE )
• LATEST ( LATEST )
• EARLIEST ( EARLIEST )

পরামিতি:

DequantizeModeAttr

Dequantization mode. Only MIN_COMBINED is supported.

সিনট্যাক্স:

#mhlo.dequantize_mode<
  ::mlir::mhlo::DequantizeMode   # value
>

Enum cases:

• MIN_COMBINED ( MIN_COMBINED )

পরামিতি:

DomainKindAttr

Kind of domain metatdata attached to an HLO domain.

সিনট্যাক্স:

#mhlo.kind<
  ::mlir::mhlo::DomainKind   # value
>

Enum cases:

• sharding ( sharding )

পরামিতি:

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
>

পরামিতি:

DotDimensionNumbersAttr

Attribute that models the dimension information for dot.

পরামিতি:

FftTypeAttr

XLA fast fourier transform type.

সিনট্যাক্স:

#mhlo.fft_type<
  ::mlir::mhlo::FftType   # value
>

Enum cases:

• FFT ( FFT )
• IFFT ( IFFT )
• RFFT ( RFFT )
• IRFFT ( IRFFT )

পরামিতি:

FusionKindAttr

fusion kind

সিনট্যাক্স:

#mhlo.fusion_kind<
  ::mlir::mhlo::FusionKind   # value
>

Enum cases:

• kLoop ( kLoop )
• kInput ( kInput )
• kOutput ( kOutput )
• kCustom ( kCustom )

পরামিতি:

GatherDimensionNumbersAttr

Attribute that models the dimension information for gather

পরামিতি:

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

পরামিতি:

PrecisionAttr

XLA precision for an operand. Has backend specific meaning.

সিনট্যাক্স:

#mhlo.precision<
  ::mlir::mhlo::Precision   # value
>

Enum cases:

• DEFAULT ( DEFAULT )
• HIGH ( HIGH )
• HIGHEST ( HIGHEST )
• PACKED_NIBBLE ( PACKED_NIBBLE )

পরামিতি:

RngAlgorithmAttr

XLA PRNG algorithm to be used.

সিনট্যাক্স:

#mhlo.rng_algorithm<
  ::mlir::mhlo::RngAlgorithm   # value
>

Enum cases:

• DEFAULT ( DEFAULT )
• THREE_FRY ( THREE_FRY )
• PHILOX ( PHILOX )

পরামিতি:

RngDistributionAttr

XLA PRNG distribution to be used.

সিনট্যাক্স:

#mhlo.rng_distribution<
  ::mlir::mhlo::RngDistribution   # value
>

Enum cases:

• UNIFORM ( UNIFORM )
• NORMAL ( NORMAL )

পরামিতি:

ScatterDimensionNumbersAttr

Attribute that models the dimension information for scatter

পরামিতি:

SparsityDescriptorAttr

Describes structured (N:M) sparsity configuration

সিনট্যাক্স:

#mhlo.sparsity<
  int64_t,   # dimension
  int64_t,   # n
  int64_t   # m
>

This attribute is defined for a sparse dot operation with a structured sparse input tensor. With (N=2,M=4), every 4 consecutive logical elements have exactly 2 non-zero physical elements in the input tensor.

$dimension defines the index of the contracting dimension that is sparse (it has to be the most minor dimension). The additional metadata operand in the sparse dot operation defines which logical elements are zeroed out.

পরামিতি:

TransposeAttr

Transpose options

সিনট্যাক্স:

#mhlo.transpose<
  ::mlir::mhlo::Transpose   # value
>

Enum cases:

• TRANSPOSE_INVALID ( TRANSPOSE_INVALID )
• NO_TRANSPOSE ( NO_TRANSPOSE )
• TRANSPOSE ( TRANSPOSE )
• ADJOINT ( ADJOINT )

পরামিতি:

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 .

পরামিতি:

প্রকারভেদ

AsyncBundleType

Opaque collection of other types

সিনট্যাক্স:

!mhlo.async_bundle<
  ::llvm::ArrayRef<Type>   # types
>

পরামিতি:

Enums

ComparisonDirection

Which comparison operation to perform.

মামলা:

ComparisonType

Which comparison type to use.

মামলা:

CustomCallApiVersion

Custom call API version

মামলা:

CustomCallSchedule

Specifies the desired schedule for the custom-call.

মামলা:

DequantizeMode

Dequantization mode. Only MIN_COMBINED is supported.

মামলা:

DomainKind

Kind of domain metatdata attached to an HLO domain.

মামলা:

FftType

XLA fast fourier transform type.

মামলা:

FusionKind

fusion kind

মামলা: