'mhlo' উপভাষা

অপারেশন

mhlo.abs (mhlo::AbsOp)

অ্যাবস অপারেশন

সিনট্যাক্স:

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

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

দেখুন: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#abs

উদাহরণ:

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

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

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

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

অপারেন্ড:

ফলাফল:

mhlo.acos (mhlo::AcosOp)

অ্যাকোস অপারেশন

সিনট্যাক্স:

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

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

উদাহরণ:

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

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

ইন্টারফেস: InferShapedTypeOpInterface , InferTypeOpInterface

অপারেন্ড:

ফলাফল:

mhlo.acosh (mhlo::AcoshOp)

অ্যাকোশ অপারেশন

সিনট্যাক্স:

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

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

উদাহরণ:

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

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

ইন্টারফেস: InferShapedTypeOpInterface , InferTypeOpInterface

অপারেন্ড:

ফলাফল:

mhlo.add (mhlo::AddOp)

অপারেশন যোগ করুন

সিনট্যাক্স:

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

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

দেখুন: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#add

উদাহরণ:

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

বৈশিষ্ট্যসমূহ: AlwaysSpeculatableImplTrait , Commutative , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

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

অপারেন্ড:

ফলাফল:

mhlo.add_dependency (mhlo::AddDependencyOp)

নির্ভরতা যোগ করার অপারেশন

সিনট্যাক্স:

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

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

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

উদাহরণ:

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

বৈশিষ্ট্য: AlwaysSpeculatableImplTrait ইমপ্ল বৈশিষ্ট্য

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

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

অপারেন্ড:

ফলাফল:

mhlo.after_all (mhlo::AfterAllOp)

আফটারঅল অপারেশন

সিনট্যাক্স:

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

এটি নিশ্চিত করে যে, result উপর নির্ভরশীল যেকোনো অপারেশনের আগে inputs প্রস্তুতকারী অপারেশনগুলো সম্পাদিত হয়।

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

দেখুন: 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)

অলরিডিউস অপারেশন

প্রসেস গ্রিডের প্রতিটি প্রসেস গ্রুপের মধ্যে, প্রতিটি প্রসেস থেকে একটি অপারেন্ড টেনসরের মানগুলোর উপর একটি রিডাকশন ফাংশন computation প্রয়োগ করা হয় এবং একটি রেজাল্ট টেনসর তৈরি করা হয়। এই computation operands এর প্রতিটি অপারেন্ডের জন্য আলাদাভাবে প্রয়োগ করা হয়, যার ফলে প্রতি অপারেন্ডের জন্য একটি করে রেজাল্ট পাওয়া যায়।

দেখুন: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#all_reduce

উদাহরণ:

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

বৈশিষ্ট্য: InferTensorType , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

ইন্টারফেস: InferShapedTypeOpInterface , InferTypeOpInterface

বৈশিষ্ট্যসমূহ:

অপারেন্ড:

ফলাফল:

mhlo.all_to_all (mhlo::AllToAllOp)

অলটুঅল অপারেশন

প্রসেস গ্রিডের প্রতিটি প্রসেস গ্রুপের মধ্যে, 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.asin (mhlo::AsinOp)

আসিন অপারেশন

সিনট্যাক্স:

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

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

উদাহরণ:

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

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

ইন্টারফেস: InferShapedTypeOpInterface , InferTypeOpInterface

অপারেন্ড:

ফলাফল:

mhlo.asinh (mhlo::AsinhOp)

আসিনহ অপারেশন

সিনট্যাক্স:

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

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

উদাহরণ:

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

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

ইন্টারফেস: InferShapedTypeOpInterface , InferTypeOpInterface

অপারেন্ড:

ফলাফল:

mhlo.async_done (mhlo::AsyncDoneOp)

অ্যাসিঙ্কডান অপারেশন

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

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

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

ইন্টারফেস: InferTypeOpInterface

অপারেন্ড:

ফলাফল:

mhlo.async_start (mhlo::AsyncStartOp)

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

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

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

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

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

এটি অ্যাসিঙ্ক অপস-এর মধ্যবর্তী সময়ের জন্য প্রয়োজনীয় সমস্ত স্টেট ফেরত দেয়। বাফার অ্যাসাইনমেন্টের পর, রিটার্ন ভ্যালুটি অ্যাসিঙ্ক অপ দ্বারা প্রয়োজনীয় বা সম্পাদিত ইনপুট, ফলাফল এবং যেকোনো স্ক্র্যাচপ্যাড ধারণ করার জন্য প্রয়োজনীয় স্থানকে নির্দেশ করে।

বৈশিষ্ট্যসমূহ:

অপারেন্ড:

ফলাফল:

mhlo.async_update (mhlo::AsyncUpdateOp)

অ্যাসিঙ্কআপডেট অপারেশন

এই অপারেশনটি 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.atanh (mhlo::AtanhOp)

আতানহ অপারেশন

সিনট্যাক্স:

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

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

উদাহরণ:

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

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

ইন্টারফেস: InferShapedTypeOpInterface , InferTypeOpInterface

অপারেন্ড:

ফলাফল:

mhlo.batch_norm_grad (mhlo::BatchNormGradOp)

ব্যাচনর্মগ্র্যাড অপারেশন

grad_output থেকে ব্যাকপ্রোপাগেট করে BatchNormTrainingOp-এর একাধিক ইনপুটের গ্রেডিয়েন্ট গণনা করে এবং grad_operand , grad_scale ও grad_offset টেনসর তৈরি করে।

দেখুন: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_grad

উদাহরণ:

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

বৈশিষ্ট্য: AlwaysSpeculatableImplTrait , InferTensorType

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

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

বৈশিষ্ট্যসমূহ:

অপারেন্ড:

ফলাফল:

mhlo.batch_norm_inference (mhlo::BatchNormInferenceOp)

ব্যাচ নর্ম ইনফারেন্স অপারেশন

feature_index ডাইমেনশনটি ছাড়া বাকি সব ডাইমেনশন জুড়ে operand টেনসরটিকে স্বাভাবিক করে এবং একটি result টেনসর তৈরি করে।

দেখুন: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_inference

উদাহরণ:

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

বৈশিষ্ট্য: AlwaysSpeculatableImplTrait , InferTensorType

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

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

বৈশিষ্ট্যসমূহ:

অপারেন্ড:

ফলাফল:

mhlo.batch_norm_training (mhlo::BatchNormTrainingOp)

ব্যাচনর্মপ্রশিক্ষণ কার্যক্রম

feature_index ডাইমেনশনের প্রতিটি ফিচারের জন্য ব্যাচ এবং স্পেশিয়াল ডাইমেনশন জুড়ে গড় ও ভেদাঙ্ক গণনা করে এবং operand টেনসরকে নর্মালাইজ করে, এবং output , batch_mean ও batch_var টেনসর তৈরি করে।

দেখুন: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#batch_norm_training

উদাহরণ:

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

বৈশিষ্ট্য: AlwaysSpeculatableImplTrait , InferTensorType

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

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

বৈশিষ্ট্যসমূহ:

অপারেন্ড:

ফলাফল:

mhlo.bitcast (mhlo::BitcastOp)

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

সিনট্যাক্স:

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

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

সহজ ভাষায় বলতে গেলে, এই প্রক্রিয়াটি ইনপুটের আকৃতি এমনভাবে পরিবর্তন করে যাতে উপাদানগুলোর ভৌত বিন্যাস অপরিবর্তিত থাকে।

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

উদাহরণ:

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

বৈশিষ্ট্য: AlwaysSpeculatableImplTrait ইমপ্ল বৈশিষ্ট্য

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

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

অপারেন্ড:

ফলাফল:

mhlo.bitcast_convert (mhlo::BitcastConvertOp)

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

সিনট্যাক্স:

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

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

দেখুন: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#bitcast_convert

উদাহরণ:

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

বৈশিষ্ট্য: AlwaysSpeculatableImplTrait ইমপ্ল বৈশিষ্ট্য

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

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

অপারেন্ড:

ফলাফল:

mhlo.broadcast (mhlo::BroadcastOp)

সম্প্রচার কার্যক্রম

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

অনানুষ্ঠানিকভাবে, এই অপারেশনটি XLA-এর ব্রডকাস্টের মতোই কাজ করে: https://www.tensorflow.org/xla/operation_semantics#broadcast

উদাহরণ:

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

বৈশিষ্ট্যসমূহ: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

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

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

বৈশিষ্ট্যসমূহ:

অপারেন্ড:

ফলাফল:

mhlo.broadcast_in_dim (mhlo::BroadcastInDimOp)

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

operand টেনসরের ডেটা প্রতিলিপি করার মাধ্যমে ইনপুট টেনসরের মাত্রা এবং/অথবা র‍্যাঙ্ক প্রসারিত করে এবং একটি result টেনসর তৈরি করে।

দেখুন: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#broadcast_in_dim

উদাহরণ:

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

বৈশিষ্ট্য: AlwaysSpeculatableImplTrait , HLO_CompatibleOperandsAndResultElementType

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

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

বৈশিষ্ট্যসমূহ:

অপারেন্ড:

ফলাফল:

mhlo.case (mhlo::CaseOp)

কেস অপারেশন

index -এর মানের উপর নির্ভর করে branches থেকে ঠিক একটি function কার্যকর করার মাধ্যমে আউটপুট তৈরি করে।

দেখুন: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#case

উদাহরণ:

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

বৈশিষ্ট্য: RecursiveMemoryEffects , SingleBlockImplicitTerminator<ReturnOp> , SingleBlock

ইন্টারফেস: InferTypeOpInterface

অপারেন্ড:

ফলাফল:

mhlo.cbrt (mhlo::CbrtOp)

সিবিআরটি অপারেশন

সিনট্যাক্স:

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

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

দেখুন: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#cbrt

উদাহরণ:

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

বৈশিষ্ট্যসমূহ: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

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

বৈশিষ্ট্যসমূহ:

অপারেন্ড:

ফলাফল:

mhlo.ceil (mhlo::CeilOp)

সিলিং অপারেশন

সিনট্যাক্স:

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

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

দেখুন: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#ceil

উদাহরণ:

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

বৈশিষ্ট্যসমূহ: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

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

অপারেন্ড:

ফলাফল:

mhlo.cholesky (mhlo::CholeskyOp)

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

একগুচ্ছ ম্যাট্রিক্সের কোলেস্কি ডিকম্পোজিশন গণনা করে।

দেখুন: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#cholesky

উদাহরণ:

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

বৈশিষ্ট্যসমূহ: AlwaysSpeculatableImplTrait , InferTensorType , SameOperandsAndResultElementType

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

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

বৈশিষ্ট্যসমূহ:

অপারেন্ড:

ফলাফল:

mhlo.clamp (mhlo::ClampOp)

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

সিনট্যাক্স:

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

operand টেনসরের প্রতিটি উপাদানকে একটি সর্বনিম্ন ও সর্বোচ্চ মানের মধ্যে সীমাবদ্ধ করে এবং একটি result টেনসর তৈরি করে।

দেখুন: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#clamp

উদাহরণ:

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

বৈশিষ্ট্যসমূহ: AlwaysSpeculatableImplTrait , HLO_BroadcastingElementwise , InferTensorType , SameOperandsAndResultElementType

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

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

অপারেন্ড:

ফলাফল:

mhlo.collective_broadcast (mhlo::CollectiveBroadcastOp)

সম্মিলিত সম্প্রচার কার্যক্রম

প্রসেস গ্রিডের প্রতিটি প্রসেস গ্রুপের মধ্যে, সোর্স প্রসেস থেকে টার্গেট প্রসেসগুলোতে operand টেনসরের মান পাঠান এবং একটি result টেনসর তৈরি করুন।

দেখুন: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#collective_broadcast

উদাহরণ:

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

বৈশিষ্ট্য: CompatibleOperandsAndResultType ফলাফলের ধরণ

ইন্টারফেস: InferShapedTypeOpInterface , InferTypeOpInterface

বৈশিষ্ট্যসমূহ:

অপারেন্ড:

ফলাফল:

mhlo.collective_permute (mhlo::CollectivePermuteOp)

সম্মিলিত পরিবর্তনকারী অপারেশন

প্রসেস গ্রিডের প্রতিটি প্রসেস গ্রুপের মধ্যে, এটি সোর্স প্রসেস থেকে টার্গেট প্রসেসে operand টেনসরের মান পাঠায় এবং একটি result টেনসর তৈরি করে।

দেখুন: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#collective_permute

উদাহরণ:

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

বৈশিষ্ট্য: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType

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

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

বৈশিষ্ট্যসমূহ:

অপারেন্ড:

ফলাফল:

mhlo.compare (mhlo::CompareOp)

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

সিনট্যাক্স:

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

comparison_direction এবং compare_type অনুযায়ী lhs ও rhs টেনসরের উপাদান-ভিত্তিক তুলনা করে এবং একটি result টেনসর তৈরি করে।

দেখুন: https://github.com/openxla/stablehlo/blob/main/docs/spec.md#compare

উদাহরণ:

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

বৈশিষ্ট্যসমূহ: AlwaysSpeculatableImplTrait , Elementwise , InferTensorType , SameOperandsAndResultShape , SameOperandsElementType

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

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

বৈশিষ্ট্যসমূহ:

অপারেন্ড:

ফলাফল:

mhlo.complex (mhlo::ComplexOp)

জটিল অপারেশন

সিনট্যাক্স:

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

একজোড়া বাস্তব ও কাল্পনিক মান ( lhs এবং rhs থেকে উপাদান-ভিত্তিক জটিল মানে রূপান্তর করে এবং একটি result টেনসর তৈরি করে।

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

উদাহরণ:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape , SameOperandsElementType

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

Effects: MemoryEffects::Effect{}

Operands:

ফলাফল:

mhlo.composite (mhlo::CompositeOp)

Composite operation

সিনট্যাক্স:

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

Encapsulates an operation made up (composed) of other StableHLO operations, taking inputs and composite_attributes and producing results . The semantics of the op are implemented by the decomposition attribute. The composite op can be replaced with its decomposition without changing program semantics. In cases where inlining the decomposition does not provide the same op semantics, prefer using custom_call .

The version field (defaults to 0 ) is used to denote when a composite's semantics change.

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

Interfaces: SymbolUserOpInterface

Attributes:

Operands:

ফলাফল:

mhlo.concatenate (mhlo::ConcatenateOp)

Concatenate operation

Concatenates a variadic number of tensors in inputs along dimension dimension in the same order as the given arguments and produces a result tensor.

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

উদাহরণ:

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

Traits: AlwaysSpeculatableImplTrait , SameOperandsAndResultElementType

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

ফলাফল:

mhlo.constant (mhlo::ConstantOp)

Constant operation

Produces an output tensor from a constant value .

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

উদাহরণ:

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

Traits: AlwaysSpeculatableImplTrait , ConstantLike

Interfaces: ConditionallySpeculatable , InferTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

ফলাফল:

mhlo.convert (mhlo::ConvertOp)

Convert operation

সিনট্যাক্স:

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

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

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

উদাহরণ:

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

Traits: AlwaysSpeculatableImplTrait , Elementwise , SameOperandsAndResultShape

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

ফলাফল:

mhlo.convolution (mhlo::ConvolutionOp)

Convolution operation

সিনট্যাক্স:

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

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

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

উদাহরণ:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

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

Attributes:

Operands:

ফলাফল:

mhlo.cosh (mhlo::CoshOp)

Cosh operation

সিনট্যাক্স:

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

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

উদাহরণ:

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

Traits: CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

Interfaces: InferShapedTypeOpInterface , InferTypeOpInterface

Operands:

ফলাফল:

mhlo.cosine (mhlo::CosineOp)

Cosine operation

সিনট্যাক্স:

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

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

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

উদাহরণ:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

ফলাফল:

mhlo.count_leading_zeros (mhlo::ClzOp)

Clz operation

সিনট্যাক্স:

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

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

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

উদাহরণ:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

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

Attributes:

Operands:

ফলাফল:

mhlo.custom_call (mhlo::CustomCallOp)

CustomCall operation

সিনট্যাক্স:

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

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

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

উদাহরণ:

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

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

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

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

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

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

Interfaces: MemoryEffectOpInterface

Attributes:

Operands:

ফলাফল:

mhlo.divide (mhlo::DivOp)

Div operation

সিনট্যাক্স:

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

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

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

উদাহরণ:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

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

Attributes:

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

Attributes:

Operands:

ফলাফল:

mhlo.dot_general (mhlo::DotGeneralOp)

DotGeneral operation

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

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

উদাহরণ:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

ফলাফল:

mhlo.dynamic_broadcast_in_dim (mhlo::DynamicBroadcastInDimOp)

DynamicBroadcastInDim operation

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

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

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

উদাহরণ:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

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

Attributes:

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

Attributes:

Operands:

ফলাফল:

mhlo.dynamic_iota (mhlo::DynamicIotaOp)

DynamicIota operation

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

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

উদাহরণ:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Attributes:

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)

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

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

উদাহরণ:

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

Traits: AlwaysSpeculatableImplTrait

Interfaces: ConditionallySpeculatable , InferShapedTypeOpInterface , NoMemoryEffect (MemoryEffectOpInterface)

Effects: MemoryEffects::Effect{}

Operands:

ফলাফল:

mhlo.dynamic_slice (mhlo::DynamicSliceOp)

DynamicSlice operation

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

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

উদাহরণ:

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

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

ফলাফল:

mhlo.dynamic_update_slice (mhlo::DynamicUpdateSliceOp)

DynamicUpdateSlice operation

সিনট্যাক্স:

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

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

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

উদাহরণ:

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

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

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

Attributes:

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.

উদাহরণ:

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

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

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

উদাহরণ:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

ফলাফল:

mhlo.exponential_minus_one (mhlo::Expm1Op)

Expm1 operation

সিনট্যাক্স:

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

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

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

উদাহরণ:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

ফলাফল:

mhlo.fft (mhlo::FftOp)

Fft operation

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

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

উদাহরণ:

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

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

ফলাফল:

mhlo.floor (mhlo::FloorOp)

Floor operation

সিনট্যাক্স:

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

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

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

উদাহরণ:

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

Traits: AlwaysSpeculatableImplTrait , CompatibleOperandsAndResultType , Elementwise , SameOperandsAndResultShape

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

Effects: MemoryEffects::Effect{}

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.

Attributes:

Operands:

ফলাফল:

mhlo.gather (mhlo::GatherOp)

Gather operation

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

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

উদাহরণ:

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

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

ফলাফল:

mhlo.get_dimension_size (mhlo::GetDimensionSizeOp)

GetDimensionSize operation

Produces the size of the given dimension of the operand .

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

উদাহরণ:

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

Traits: AlwaysSpeculatableImplTrait , InferTensorType

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

Effects: MemoryEffects::Effect{}

Attributes:

Operands:

ফলাফল: