StableHLO স্পেসিফিকেশন

StableHLO হল মেশিন লার্নিং (ML) মডেলগুলিতে উচ্চ-স্তরের অপারেশন (HLO) এর জন্য একটি অপারেশন সেট। StableHLO বিভিন্ন ML ফ্রেমওয়ার্ক এবং ML কম্পাইলারের মধ্যে একটি পোর্টেবিলিটি স্তর হিসাবে কাজ করে: StableHLO প্রোগ্রাম তৈরি করে এমন ML ফ্রেমওয়ার্কগুলি StableHLO প্রোগ্রাম ব্যবহার করে এমন ML কম্পাইলারের সাথে সামঞ্জস্যপূর্ণ।

আমাদের লক্ষ্য হল বিভিন্ন ML ফ্রেমওয়ার্ক (যেমন TensorFlow, JAX এবং PyTorch) এবং ML কম্পাইলার (যেমন XLA এবং IREE) এর মধ্যে আরও আন্তঃকার্যক্ষমতা তৈরি করে ML ডেভেলপমেন্টকে সহজ এবং ত্বরান্বিত করা। সেই লক্ষ্যে, এই ডকুমেন্টটি StableHLO প্রোগ্রামিং ভাষার জন্য একটি স্পেসিফিকেশন প্রদান করে।

এই স্পেসিফিকেশনে তিনটি প্রধান বিভাগ রয়েছে। প্রথমত, প্রোগ্রাম বিভাগটি StableHLO প্রোগ্রামগুলির কাঠামো বর্ণনা করে যা StableHLO ফাংশন নিয়ে গঠিত যা নিজেই StableHLO অপশন নিয়ে গঠিত। এই কাঠামোর মধ্যে, Ops বিভাগটি পৃথক অপশনের শব্দার্থবিদ্যা নির্দিষ্ট করে। এক্সিকিউশন বিভাগটি একটি প্রোগ্রামের মধ্যে একসাথে সম্পাদিত এই সমস্ত অপশনের শব্দার্থবিদ্যা প্রদান করে। অবশেষে, নোটেশন বিভাগটি স্পেসিফিকেশন জুড়ে ব্যবহৃত নোটেশন নিয়ে আলোচনা করে।

StableHLO এর পূর্ববর্তী রিলিজের স্পেসিফিকেশন দেখতে, ট্যাগ করা রিলিজ অফ ইন্টারেস্ট-এ রেপো খুলুন। উদাহরণস্বরূপ, StableHLO v0.19.0 Spec । StableHLO এর প্রতিটি ছোট সংস্করণ বাম্পে ঘটে যাওয়া পরিবর্তনগুলি দেখতে, VhloDialect.td- এ সংস্করণ লগটি দেখুন।

প্রোগ্রাম

Program ::= {Func}

StableHLO প্রোগ্রামগুলিতে নির্দিষ্ট সংখ্যক StableHLO ফাংশন থাকে। নিচে @main ফাংশন সহ একটি প্রোগ্রামের উদাহরণ দেওয়া হল যার ৩টি ইনপুট ( %image , %weights এবং %bias ) এবং ১টি আউটপুট রয়েছে। ফাংশনের বডিতে ৬টি অপশন রয়েছে।

func.func @main(
  %image: tensor<28x28xf32>,
  %weights: tensor<784x10xf32>,
  %bias: tensor<1x10xf32>
) -> tensor<1x10xf32> {
  %0 = "stablehlo.reshape"(%image) : (tensor<28x28xf32>) -> tensor<1x784xf32>
  %1 = "stablehlo.dot"(%0, %weights) : (tensor<1x784xf32>, tensor<784x10xf32>) -> tensor<1x10xf32>
  %2 = "stablehlo.add"(%1, %bias) : (tensor<1x10xf32>, tensor<1x10xf32>) -> tensor<1x10xf32>
  %3 = "stablehlo.constant"() {value = dense<0.0> : tensor<1x10xf32>} : () -> tensor<1x10xf32>
  %4 = "stablehlo.maximum"(%2, %3) : (tensor<1x10xf32>, tensor<1x10xf32>) -> tensor<1x10xf32>
  "func.return"(%4): (tensor<1x10xf32>) -> ()
}

ফাংশন

Func        ::= 'func' '.' 'func' FuncId FuncInputs FuncOutputs '{' FuncBody '}'
FuncInputs  ::= '(' [FuncInput {',' FuncInput}] `)`
FuncInput   ::= ValueId ':' ValueType
FuncOutputs ::= ['->' FuncOutput, {',' FuncOutput}]
FuncOutput  ::= ValueType
FuncBody    ::= {Op}

StableHLO ফাংশনগুলির (যাকে নামযুক্ত ফাংশনও বলা হয়) একটি শনাক্তকারী, ইনপুট/আউটপুট এবং একটি বডি থাকে। ভবিষ্যতে, আমরা HLO ( #425 , #626 , #740 , #744 ) এর সাথে আরও ভাল সামঞ্জস্য অর্জনের জন্য ফাংশনগুলির জন্য অতিরিক্ত মেটাডেটা প্রবর্তনের পরিকল্পনা করছি।

শনাক্তকারী

FuncId  ::= '@' letter {letter | digit}
ValueId ::= '%' digit {digit}
          | '%' letter {letter | digit}
letter  ::= 'a' | ... | 'z' | 'A' | ... | 'Z' | '_'
digit   ::= '0' | ... | '9'

StableHLO শনাক্তকারী অনেক প্রোগ্রামিং ভাষার শনাক্তকারীর মতোই, যার দুটি বিশেষত্ব রয়েছে: ১) সমস্ত শনাক্তকারীর সিগিল থাকে যা বিভিন্ন ধরণের শনাক্তকারীকে আলাদা করে, ২) StableHLO প্রোগ্রাম তৈরি সহজ করার জন্য মান শনাক্তকারী সম্পূর্ণ সংখ্যাসূচক হতে পারে।

প্রকারভেদ

Type         ::= ValueType | NonValueType
ValueType    ::= TensorType | QuantizedTensorType | TokenType | TupleType | BufferType
NonValueType ::= TensorElementType | QuantizedTensorElementType | FunctionType | StringType

StableHLO প্রকারগুলিকে মান প্রকারে (যাকে প্রথম-শ্রেণীর প্রকারও বলা হয়) শ্রেণীবদ্ধ করা হয় যা StableHLO মান এবং অ-মান প্রকার যা অন্যান্য প্রোগ্রাম উপাদানগুলিকে বর্ণনা করে। StableHLO প্রকারগুলি অনেক প্রোগ্রামিং ভাষার প্রকারের অনুরূপ, যার প্রধান বৈশিষ্ট্য হল StableHLO এর ডোমেন-নির্দিষ্ট প্রকৃতি যা কিছু অস্বাভাবিক ফলাফলের দিকে পরিচালিত করে (যেমন স্কেলার প্রকারগুলি মান প্রকার নয়)।

TensorType ::= 'tensor' '<' Shape TensorElementType '>'
Shape ::= {DimensionSize 'x'}
DimensionSize ::= digit {digit} | '?'

টেনসরের ধরণগুলি টেনসর, অর্থাৎ বহুমাত্রিক অ্যারেগুলিকে প্রতিনিধিত্ব করে। তাদের একটি আকৃতি এবং একটি উপাদানের ধরণ থাকে, যেখানে একটি আকৃতি 0 থেকে R-1 পর্যন্ত সংখ্যাযুক্ত সংশ্লিষ্ট মাত্রার (যাকে অক্ষও বলা হয়) ঊর্ধ্বমুখী ক্রমে অ-ঋণাত্মক বা অজানা মাত্রার আকারগুলিকে প্রতিনিধিত্ব করে। মাত্রার সংখ্যা R rank বলা হয়। উদাহরণস্বরূপ, tensor<2x3xf32> হল একটি টেনসরের ধরণ যার আকৃতি 2x3 এবং উপাদানের ধরণ f32 । এর দুটি মাত্রা (অথবা, অন্য কথায়, দুটি অক্ষ) রয়েছে - 0 তম মাত্রা এবং 1 ম মাত্রা - যার আকার 2 এবং 3। এর র‍্যাঙ্ক হল 2।

আকৃতি আংশিক বা সম্পূর্ণ অজানা (গতিশীল) হতে পারে, যেমন tensor<?x2xf64> আংশিক অজানা এবং tensor<?x?xf64> সম্পূর্ণ অজানা। গতিশীল মাত্রার আকারগুলি ? ব্যবহার করে উপস্থাপন করা হয়। আকৃতিগুলিকে অর‍্যাঙ্ক করা যাবে না।

ভবিষ্যতে, আমরা মাত্রা আকার এবং উপাদান প্রকারের বাইরেও টেনসর প্রকারগুলি প্রসারিত করার পরিকল্পনা করছি, উদাহরণস্বরূপ, লেআউট ( #629 ) এবং স্পারসিটি ( #1078 ) অন্তর্ভুক্ত করার জন্য।

QuantizedTensorType ::= 'tensor' '<' Shape QuantizedTensorElementType '>'
QuantizedTensorElementType ::= '!quant.uniform' '<'
                  QuantizationStorageType
                  ['<' QuantizationStorageMin ':' QuantizationStorageMax '>']
                  ':' QuantizationExpressedType
                  [':' QuantizationDimension]
                  ',' QuantizationParameters '>'
QuantizationStorageType ::= IntegerType
QuantizationStorageMin ::= IntegerLiteral
QuantizationStorageMax ::= IntegerLiteral
QuantizationExpressedType ::= FloatType
QuantizationDimension ::= IntegerLiteral
QuantizationParameters ::= QuantizationParameter
                         | '{' QuantizationParameter {',' QuantizationParameter} '}'
QuantizationParameter ::= QuantizationScale [':' QuantizationZeroPoint]
QuantizationScale ::= FloatLiteral
QuantizationZeroPoint ::= IntegerLiteral

কোয়ান্টাইজড এলিমেন্ট টাইপগুলি স্টোরেজ টাইপের পূর্ণসংখ্যার মানগুলিকে storage_min থেকে storage_max (inclusive) পর্যন্ত পরিসরে উপস্থাপন করে যা একটি প্রকাশিত টাইপের ফ্লোটিং-পয়েন্ট মানের সাথে সঙ্গতিপূর্ণ। একটি প্রদত্ত পূর্ণসংখ্যা মানের i এর জন্য, সংশ্লিষ্ট ফ্লোটিং-পয়েন্ট মান f f = (i - zero_point) * scale হিসাবে গণনা করা যেতে পারে, যেখানে scale এবং zero_point quantization প্যারামিটার বলা হয়। storage_min এবং storage_max ব্যাকরণে ঐচ্ছিক, তবে যথাক্রমে min_value(storage_type) এবং max_value(storage_type) এর ডিফল্ট মান রয়েছে। কোয়ান্টাইজড এলিমেন্ট টাইপের নিম্নলিখিত সীমাবদ্ধতা রয়েছে:

• (C1) type(storage_min) = storage_type ।
• (C2) type(storage_max) = storage_type ।
• (C3) min_value(storage_type) <= storage_min < storage_max <= max_value(storage_type) .
• (C4) type(scales...) = expressed_type ।
• (C5) 0 < scales < .
• (C6) is_finite(scales...) ।
• (C7) storage_min <= zero_points <= storage_max .
• (C8) type(zero_points...) = storage_type ।
• (C9) size(scales) = size(zero_points) .
• (C10) যদি is_empty(quantization_dimension) , তাহলে size(scales) = 1 ।
• (C11) 0 <= quantization_dimension .

এই মুহূর্তে, QuantizationScale একটি ভাসমান-বিন্দু ধ্রুবক, তবে গুণক এবং শিফট দিয়ে উপস্থাপিত পূর্ণসংখ্যা-ভিত্তিক স্কেলগুলিতে প্রবল আগ্রহ রয়েছে। আমরা নিকট ভবিষ্যতে এটি অন্বেষণ করার পরিকল্পনা করছি ( #1404 )।

QuantizationZeroPoint এর শব্দার্থবিদ্যা নিয়ে আলোচনা চলছে, যার মধ্যে রয়েছে ধরণ, মান এবং একটি কোয়ান্টাইজড টেনসর টাইপে কেবল একটি বা সম্ভাব্য একাধিক শূন্য বিন্দু থাকতে পারে কিনা। এই আলোচনার ফলাফলের উপর ভিত্তি করে, শূন্য বিন্দুর চারপাশের স্পেসিফিকেশন ভবিষ্যতে পরিবর্তিত হতে পারে ( #1405 )।

আরেকটি চলমান আলোচনার মধ্যে রয়েছে QuantizationStorageMin এবং QuantizationStorageMax এর শব্দার্থবিদ্যা, যা নির্ধারণ করে যে এই মানগুলির উপর এবং কোয়ান্টাইজড টেনসরের মানগুলির উপর কোনও সীমাবদ্ধতা আরোপ করা উচিত কিনা ( #1406 )।

অবশেষে, আমরা অজানা স্কেল এবং শূন্য বিন্দু প্রতিনিধিত্ব করে অন্বেষণ করার পরিকল্পনা করছি, ঠিক একইভাবে আমরা অজানা মাত্রা আকার ( #1407 ) প্রতিনিধিত্ব করে অন্বেষণ করার পরিকল্পনা করছি।

কোয়ান্টাইজড টেনসর প্রকারগুলি কোয়ান্টাইজড উপাদান সহ টেনসরগুলিকে প্রতিনিধিত্ব করে। এই টেনসরগুলি নিয়মিত টেনসরগুলির মতোই, তবে তাদের উপাদানগুলিতে নিয়মিত উপাদান ধরণের পরিবর্তে কোয়ান্টাইজড উপাদান ধরণের থাকে।

কোয়ান্টাইজড টেনসরগুলিতে, কোয়ান্টাইজেশন হতে পারে per-tensor , যার অর্থ, সমগ্র টেনসরের জন্য একটি scale এবং zero_point থাকা অথবা per-axis , যার অর্থ, একাধিক scales এবং zero_points থাকা, একটি নির্দিষ্ট মাত্রা quantization_dimension এর প্রতি স্লাইসে একটি জোড়া। আরও আনুষ্ঠানিকভাবে, per-axis quantization সহ একটি টেনসর t তে, quantization_dimension এর dim(t, quantization_dimension) স্লাইস থাকে : t[:, ..., 0, ..., :], t[:, ..., 1, ..., :] , ইত্যাদি। i তম স্লাইসের সমস্ত উপাদান তাদের কোয়ান্টাইজেশন প্যারামিটার হিসাবে scales[i] এবং zero_points[i] ব্যবহার করে। কোয়ান্টাইজড টেনসর প্রকারের নিম্নলিখিত সীমাবদ্ধতা রয়েছে:

• প্রতি-টেনসর কোয়ান্টাইজেশনের জন্য:
  • কোনও অতিরিক্ত বাধা নেই।
• প্রতি-অক্ষের পরিমাণ নির্ধারণের জন্য:
  • (C12) quantization_dimension < rank(self) .
  • (C13) dim(self, quantization_dimension) = size(scales) .

TokenType ::= 'token'

টোকেনের ধরণগুলি টোকেনগুলিকে প্রতিনিধিত্ব করে, অর্থাৎ কিছু ক্রিয়াকলাপ দ্বারা উৎপাদিত এবং ব্যবহৃত অস্বচ্ছ মান। এক্সিকিউশন বিভাগে বর্ণিত ক্রিয়াকলাপগুলিতে এক্সিকিউশন অর্ডার আরোপের জন্য টোকেনগুলি ব্যবহৃত হয়।

TupleType ::= 'tuple' '<' TupleElementTypes '>'
TupleElementTypes ::= [ValueType {',' ValueType}]

বাফারের ধরণগুলি বাফারগুলিকে প্রতিনিধিত্ব করে। উদাহরণস্বরূপ, XLA-তে, বাফারগুলি হল বহুমাত্রিক অ্যারে যার মধ্যে সামঞ্জস্যপূর্ণ স্টোরেজ রয়েছে। টেনসরের ধরণগুলির মতো, বাফারের ধরণগুলির একটি আকৃতি এবং একটি উপাদানের ধরণ থাকে, যেখানে একটি আকৃতি 0 থেকে R-1 পর্যন্ত সংখ্যাযুক্ত সংশ্লিষ্ট মাত্রার (যাকে অক্ষও বলা হয়) ঊর্ধ্বমুখী ক্রমে অ-ঋণাত্মক বা অজানা মাত্রার আকারগুলিকে প্রতিনিধিত্ব করে। মাত্রার সংখ্যা R rank বলা হয়। উদাহরণস্বরূপ, memref<2x3xf32> হল একটি বাফার প্রকার যার আকৃতি 2x3 এবং উপাদানের ধরণ f32 । এর দুটি মাত্রা (অথবা, অন্য কথায়, দুটি অক্ষ) রয়েছে - 0 তম মাত্রা এবং 1 ম মাত্রা - যার আকার 2 এবং 3। এর র‍্যাঙ্ক হল 2।

CreateBuffer অথবা Pin এ custom_call ব্যবহার করে বাফার বরাদ্দ করা যেতে পারে এবং Unpin এ custom_call এর মাধ্যমে ডিলোকেট করা যেতে পারে। শুধুমাত্র custom_call অপারেটররা বাফারের ভিতরের বিষয়বস্তু পড়তে এবং লিখতে পারে। আরও বিস্তারিত জানার জন্য custom_call দেখুন।

টিউপল প্রকারগুলি টিউপল, অর্থাৎ ভিন্ন ভিন্ন তালিকাগুলিকে প্রতিনিধিত্ব করে। টিউপলগুলি একটি লিগ্যাসি বৈশিষ্ট্য যা শুধুমাত্র HLO-এর সাথে সামঞ্জস্যের জন্য বিদ্যমান। HLO-তে, টিউপলগুলি ভেরিয়াডিক ইনপুট এবং আউটপুট উপস্থাপন করতে ব্যবহৃত হয়। StableHLO-তে, ভেরিয়াডিক ইনপুট এবং আউটপুটগুলি স্থানীয়ভাবে সমর্থিত হয় এবং StableHLO-তে টিউপলের একমাত্র ব্যবহার হল HLO ABI-কে ব্যাপকভাবে উপস্থাপন করা যেখানে যেমন T , tuple<T> এবং tuple<tuple<T>> একটি নির্দিষ্ট বাস্তবায়নের উপর নির্ভর করে বস্তুগতভাবে ভিন্ন হতে পারে। ভবিষ্যতে, আমরা HLO ABI-তে পরিবর্তন করার পরিকল্পনা করছি যা আমাদের StableHLO ( #598 ) থেকে টিউপল প্রকারগুলি অপসারণ করতে সাহায্য করতে পারে।

TensorElementType ::= BooleanType | IntegerType | FloatType | ComplexType
BooleanType ::= 'i1'
IntegerType ::= SignedIntegerType | UnsignedIntegerType
SignedIntegerType ::= 'si2' | 'si4' | 'si8' | 'si16' | 'si32' | 'si64'
UnsignedIntegerType ::= 'ui2' | 'ui4' | 'ui8' | 'ui16' | 'ui32' | 'ui64'
FloatType ::= 'f4E2M1FN' | 'f6E2M3FN' | 'f6E3M2FN' | 'f8E3M4' | 'f8E4M3'
            | 'f8E4M3FN' | 'f8E4M3FNUZ' | 'f8E4M3B11FNUZ' | 'f8E5M2'
            | 'f8E5M2FNUZ' | 'f8E8M0FNU' | 'bf16' | 'f16' | 'f32' | 'f64'
TensorFloat32 ::= 'tf32'
ComplexType ::= 'complex' '<' ComplexElementType '>'
ComplexElementType ::= 'f32' | 'f64'

এলিমেন্ট টাইপগুলি টেনসর টাইপের উপাদানগুলিকে প্রতিনিধিত্ব করে। অনেক প্রোগ্রামিং ভাষার বিপরীতে, এই টাইপগুলি StableHLO তে প্রথম শ্রেণীর নয়। এর অর্থ হল StableHLO প্রোগ্রামগুলি সরাসরি এই ধরণের মানগুলি উপস্থাপন করতে পারে না (ফলস্বরূপ, T টাইপের স্কেলার মানগুলিকে 0-মাত্রিক টেনসর মানের সাথে tensor<T> টাইপের উপস্থাপন করা বাগধারার মতো)।

• বুলিয়ান টাইপ বুলিয়ান মানগুলিকে true এবং false হিসাবে উপস্থাপন করে।
• পূর্ণসংখ্যার ধরণগুলি স্বাক্ষরিত ( si ) অথবা স্বাক্ষরবিহীন ( ui ) হতে পারে এবং সমর্থিত বিট প্রস্থগুলির মধ্যে একটি ( 2 , 4 , 8 , 16 , 32 , অথবা 64 ) থাকতে পারে। স্বাক্ষরিত siN প্রকারগুলি -2^(N-1) থেকে 2^(N-1)-1 পর্যন্ত পূর্ণসংখ্যার মান উপস্থাপন করে এবং স্বাক্ষরবিহীন uiN প্রকারগুলি 0 থেকে 2^N-1 পর্যন্ত পূর্ণসংখ্যার মান উপস্থাপন করে।
• ফ্লোটিং-পয়েন্টের ধরণগুলি নিম্নলিখিতগুলির মধ্যে একটি হতে পারে:
  • IEEE-754 কনভেনশন অনুসরণ করে f8E3M4 , f8E4M3 এবং f8E5M2 8-বিট ফ্লোটিং পয়েন্ট নম্বর।
  • FP8 ফর্ম্যাট ফর ডিপ লার্নিং -এ বর্ণিত FP8 ফর্ম্যাটের E4M3 এবং E5M2 এনকোডিংগুলির সাথে যথাক্রমে f8E4M3FN এবং f8E5M2 প্রকারগুলি।
  • ডিপ নিউরাল নেটওয়ার্কের জন্য 8-বিট নিউমেরিক্যাল ফর্ম্যাটে বর্ণিত FP8 ফর্ম্যাটের E4M3 এবং E5M2 এনকোডিংয়ের সাথে সম্পর্কিত f8E4M3FNUZ এবং f8E5M2FNUZ প্রকারগুলি।
  • হাইব্রিড 8-বিট ফ্লোটিং পয়েন্ট (HFP8) ট্রেনিং এবং ইনফারেন্স ফর ডিপ নিউরাল নেটওয়ার্কে বর্ণিত FP8 ফর্ম্যাটের E4M3 এনকোডিংয়ের সাথে সম্পর্কিত f8E4M3B11FNUZ টাইপ।
  • BFloat16: ক্লাউড TPU-তে উচ্চ কর্মক্ষমতার রহস্য -এ বর্ণিত bfloat16 ফর্ম্যাটের সাথে সঙ্গতিপূর্ণ bf16 টাইপ।
  • IEEE 754 স্ট্যান্ডার্ডে বর্ণিত যথাক্রমে binary16 ("অর্ধেক নির্ভুলতা"), binary32 ("একক নির্ভুলতা") এবং binary64 ("দ্বৈত নির্ভুলতা") ফর্ম্যাটের সাথে সম্পর্কিত f16 , f32 এবং f64 প্রকার।
  • tf32 টাইপ TensorFloat32 ফর্ম্যাটের সাথে সামঞ্জস্যপূর্ণ এবং StableHLO তে সীমিত সমর্থন রয়েছে।
  • OCP মাইক্রোস্কেলিং ফর্ম্যাট স্পেসিফিকেশনে বর্ণিত f4E2M1FN , f6E2M3FN , f6E3M2FN এবং f8E8M0FNU MX (মাইক্রোস্কেলিং) প্রকারগুলি।
• জটিল প্রকারগুলি এমন জটিল মানগুলিকে প্রতিনিধিত্ব করে যার একটি বাস্তব অংশ এবং একই উপাদান ধরণের একটি কাল্পনিক অংশ থাকে। সমর্থিত জটিল প্রকারগুলি হল complex<f32> (উভয় অংশই f32 ধরণের) এবং complex<f64> (উভয় অংশই f64 ধরণের)।

FunctionType ::= '(' InputTypes ')' '->' '(' OutputTypes ')'
InputTypes ::= [ValueType {',' ValueType}]
OutputTypes ::= [ValueType {',' ValueType}]

ফাংশনের ধরণগুলি নামযুক্ত এবং বেনামী উভয় ফাংশনকেই প্রতিনিধিত্ব করে। এগুলির ইনপুট প্রকার ( -> এর বাম দিকের প্রকারের তালিকা) এবং আউটপুট প্রকার ( -> এর ডানদিকের প্রকারের তালিকা) রয়েছে। অনেক প্রোগ্রামিং ভাষায়, ফাংশনের ধরণগুলি প্রথম শ্রেণীর, কিন্তু StableHLO তে নয়।

StringType ::= 'string'

স্ট্রিং টাইপ বাইটের ক্রম নির্দেশ করে। অনেক প্রোগ্রামিং ভাষার বিপরীতে, StableHLO তে স্ট্রিং টাইপ প্রথম শ্রেণীর নয় এবং শুধুমাত্র প্রোগ্রাম উপাদানগুলির জন্য স্ট্যাটিক মেটাডেটা নির্দিষ্ট করতে ব্যবহৃত হয়।

অপারেশনস

StableHLO অপারেশন (যাকে ops ও বলা হয়) মেশিন লার্নিং মডেলগুলিতে উচ্চ-স্তরের অপারেশনের একটি বদ্ধ সেট প্রতিনিধিত্ব করে। উপরে আলোচনা করা হয়েছে, StableHLO সিনট্যাক্সটি MLIR দ্বারা ব্যাপকভাবে অনুপ্রাণিত, যা অগত্যা সবচেয়ে এর্গোনোমিক বিকল্প নয়, তবে ML ফ্রেমওয়ার্ক এবং ML কম্পাইলারের মধ্যে আরও আন্তঃকার্যক্ষমতা তৈরির StableHLO-এর লক্ষ্যের জন্য এটি যুক্তিসঙ্গতভাবে সবচেয়ে উপযুক্ত।

Op            ::= [OpOutputs] OpName OpInputs ':' OpSignature
OpName        ::= '"' 'stablehlo' '.' OpMnemonic '"'
OpMnemonic    ::= 'abs' | 'add' | ...

StableHLO অপারেশনগুলির (যাকে ops ও বলা হয়) একটি নাম, ইনপুট/আউটপুট এবং একটি স্বাক্ষর থাকে। নামটিতে stablehlo. প্রিফিক্স এবং একটি স্মৃতিচিহ্ন থাকে যা সমর্থিত অপশনগুলির মধ্যে একটিকে অনন্যভাবে সনাক্ত করে। সমস্ত সমর্থিত অপশনের একটি বিস্তৃত তালিকার জন্য নীচে দেখুন।

OpInputs        ::= OpInputValues OpInputFuncs OpInputAttrs
OpInputValues   ::= '(' [OpInputValue {',' OpInputValue}] ')'
OpInputValue    ::= ValueId
OpInputFuncs    ::= ['(' OpInputFunc {',' OpInputFunc} ')']
OpInputAttrs    ::= ['{' OpInputAttr {',' OpInputAttr} '}']
OpOutputs       ::= [OpOutput {',' OpOutput} '=']
OpOutput        ::= ValueId

Ops ইনপুট ব্যবহার করে এবং আউটপুট তৈরি করে। ইনপুটগুলিকে ইনপুট মান (কার্যকরনের সময় গণনা করা হয়), ইনপুট ফাংশন (স্ট্যাটিক্যালি প্রদান করা হয়, কারণ StableHLO তে ফাংশনগুলি প্রথম শ্রেণীর মান নয়) এবং ইনপুট অ্যাট্রিবিউট (স্ট্যাটিক্যালি প্রদান করা হয়) এ শ্রেণীবদ্ধ করা হয়। একটি op দ্বারা ব্যবহৃত এবং উৎপাদিত ইনপুট এবং আউটপুটগুলির ধরণ তার স্মৃতিশক্তির উপর নির্ভর করে। উদাহরণস্বরূপ, add op 2 ইনপুট মান ব্যবহার করে এবং 1 আউটপুট মান তৈরি করে। তুলনামূলকভাবে, select_and_scatter op 3 ইনপুট মান, 2 ইনপুট ফাংশন এবং 3 ইনপুট অ্যাট্রিবিউট ব্যবহার করে।

OpInputFunc ::= '{' Unused FuncInputs ':' FuncBody '}'
Unused      ::= '^' digit {digit}
              | '^' letter {letter | digit}

ইনপুট ফাংশন (যাকে বেনামী ফাংশনও বলা হয়) নামযুক্ত ফাংশনের সাথে খুব মিল, তবে এগুলি হল: ১) তাদের কোনও শনাক্তকারী নেই (তাই নাম "বেনামী"), ২) তারা আউটপুট প্রকার ঘোষণা করে না (আউটপুট প্রকারগুলি ফাংশনের মধ্যে return অপ থেকে অনুমান করা হয়)।

ইনপুট ফাংশনের সিনট্যাক্সে বর্তমানে অব্যবহৃত একটি অংশ (উপরের Unused প্রোডাকশন দেখুন) অন্তর্ভুক্ত থাকে যা MLIR-এর সাথে সামঞ্জস্যের জন্য রয়েছে। MLIR-এ, "অঞ্চল" সম্পর্কে আরও সাধারণ ধারণা রয়েছে যেখানে একাধিক "ব্লক" অপশন জাম্প অপশনের মাধ্যমে একসাথে সংযুক্ত থাকতে পারে। এই ব্লকগুলিতে এমন আইডি রয়েছে যা Unused প্রোডাকশনের সাথে সামঞ্জস্যপূর্ণ, যাতে তাদের একে অপরের থেকে আলাদা করা যায়। StableHLO-তে জাম্প অপশন নেই, তাই MLIR সিনট্যাক্সের সংশ্লিষ্ট অংশটি অব্যবহৃত (তবে এখনও আছে)।

OpInputAttr      ::= OpInputAttrName '=' OpInputAttrValue
OpInputAttrName  ::= letter {letter | digit}
OpInputAttrValue ::= Constant

ইনপুট অ্যাট্রিবিউটের একটি নাম এবং একটি মান থাকে যা সমর্থিত ধ্রুবকগুলির মধ্যে একটি। এগুলি প্রোগ্রাম উপাদানগুলির জন্য স্ট্যাটিক মেটাডেটা নির্দিষ্ট করার প্রাথমিক উপায়। উদাহরণস্বরূপ, concatenate op অ্যাট্রিবিউট dimension ব্যবহার করে তার ইনপুট মানগুলি যে মাত্রা বরাবর সংযুক্ত করা হয় তা নির্দিষ্ট করে। একইভাবে, slice op ইনপুট মান স্লাইস করতে ব্যবহৃত সীমানা নির্দিষ্ট করতে start_indices এবং limit_indices মতো একাধিক অ্যাট্রিবিউট ব্যবহার করে।

বর্তমানে, StableHLO প্রোগ্রামগুলিতে মাঝে মাঝে এমন বৈশিষ্ট্য থাকে যা এই নথিতে বর্ণিত নেই। ভবিষ্যতে, আমরা এই বৈশিষ্ট্যগুলিকে StableHLO অপসেটে অন্তর্ভুক্ত করার পরিকল্পনা করছি অথবা StableHLO প্রোগ্রামগুলিতে তাদের উপস্থিতি নিষিদ্ধ করার পরিকল্পনা করছি। ইতিমধ্যে, এখানে এই বৈশিষ্ট্যগুলির তালিকা রয়েছে:

• layout ( #629 )।
• mhlo.frontend_attributes ( #628 )।
• mhlo.sharding ( #619 )।
• output_operand_aliases ( #740 )।
• অবস্থান মেটাডেটা ( #594 )।

OpSignature ::= '(' [ValueType {',' ValueType}] ')' '->' '(' [ValueType {',' ValueType}] ')'

Op স্বাক্ষরে সকল ইনপুট মানের ধরণ ( -> এর বাম দিকের প্রকারের তালিকা) এবং সকল আউটপুট মানের ধরণ ( -> এর ডান দিকের প্রকারের তালিকা) থাকে। স্পষ্টভাবে বলতে গেলে, ইনপুট প্রকারগুলি অপ্রয়োজনীয়, এবং আউটপুট প্রকারগুলিও প্রায় সর্বদা অপ্রয়োজনীয় (কারণ বেশিরভাগ StableHLO অপশনের ক্ষেত্রে, ইনপুট থেকে আউটপুট প্রকারগুলি অনুমান করা যেতে পারে)। তবুও, MLIR এর সাথে সামঞ্জস্যের জন্য op স্বাক্ষর ইচ্ছাকৃতভাবে StableHLO সিনট্যাক্সের অংশ।

নিচে একটি উদাহরণ দেওয়া হল op যার স্মৃতিশক্তি হল select_and_scatter । এটি 3টি ইনপুট মান ( %operand , %source এবং %init_value ), 2টি ইনপুট ফাংশন এবং 3টি ইনপুট অ্যাট্রিবিউট ( window_dimensions , window_strides এবং padding ) ব্যবহার করে। লক্ষ্য করুন কিভাবে op এর স্বাক্ষরে শুধুমাত্র তার ইনপুট মানগুলির প্রকারগুলি অন্তর্ভুক্ত থাকে (কিন্তু ইনলাইনে প্রদত্ত ইনপুট ফাংশন এবং অ্যাট্রিবিউটগুলির প্রকারগুলি নয়)।

%result = "stablehlo.select_and_scatter"(%operand, %source, %init_value) ({
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "stablehlo.compare"(%arg0, %arg1) {
      comparison_direction = #stablehlo<comparison_direction GE>
    } : (tensor<i32>, tensor<i32>) -> tensor<i1>
    "stablehlo.return"(%0) : (tensor<i1>) -> ()
}, {
  ^bb0(%arg0: tensor<i32>, %arg1: tensor<i32>):
    %0 = "stablehlo.add"(%arg0, %arg1) : (tensor<i32>, tensor<i32>) -> tensor<i32>
    "stablehlo.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>

ধ্রুবক

Constant ::= BooleanConstant
           | IntegerConstant
           | FloatConstant
           | ComplexConstant
           | TensorConstant
           | QuantizedTensorConstant
           | StringConstant
           | EnumConstant

StableHLO ধ্রুবকের একটি আক্ষরিক এবং একটি প্রকার থাকে যা একসাথে একটি StableHLO মান উপস্থাপন করে। সাধারণত, প্রকারটি ধ্রুবক বাক্য গঠনের অংশ, যখন এটি দ্ব্যর্থহীন হয় (যেমন একটি বুলিয়ান ধ্রুবকের দ্ব্যর্থহীনভাবে type i1 থাকে, যেখানে একটি পূর্ণসংখ্যা ধ্রুবকের একাধিক সম্ভাব্য প্রকার থাকতে পারে)।

BooleanConstant ::= BooleanLiteral
BooleanLiteral  ::= 'true' | 'false'

বুলিয়ান ধ্রুবকগুলি বুলিয়ান মানগুলিকে true এবং false হিসাবে উপস্থাপন করে। বুলিয়ান ধ্রুবকগুলির ধরণ i1 ।

IntegerConstant   ::= IntegerLiteral ':' IntegerType
IntegerLiteral    ::= ['-' | '+'] DecimalDigits
                    | ['-' | '+'] '0x' HexadecimalDigits
DecimalDigits     ::= decimalDigit {decimalDigit}
HexadecimalDigits ::= hexadecimalDigit {hexadecimalDigit}
decimalDigit      ::= '0' | ... | '9'
hexadecimalDigit  ::= decimalDigit | 'a' | ... | 'f' | 'A' | ... | 'F'

পূর্ণসংখ্যার ধ্রুবকগুলি দশমিক বা হেক্সাডেসিমেল স্বরলিপি ব্যবহার করে এমন স্ট্রিংগুলির মাধ্যমে পূর্ণসংখ্যার মান উপস্থাপন করে। অন্যান্য ভিত্তি, যেমন বাইনারি বা অক্টাল, সমর্থিত নয়। পূর্ণসংখ্যার ধ্রুবকগুলির নিম্নলিখিত সীমাবদ্ধতা রয়েছে:

• (C1) is_wellformed(integer_literal, integer_type) ।

FloatConstant  ::= FloatLiteral ':' FloatType
FloatLiteral   ::= SignPart IntegerPart FractionalPart ScientificPart
                 | '0x' [HexadecimalDigits]
SignPart       ::= ['-' | '+']
IntegerPart    ::= DecimalDigits
FractionalPart ::= ['.' [DecimalDigits]]
ScientificPart ::= [('e' | 'E') ['-' | '+'] DecimalDigits]

ভাসমান-পয়েন্ট ধ্রুবকগুলি দশমিক বা বৈজ্ঞানিক স্বরলিপি ব্যবহার করে এমন স্ট্রিংগুলির মাধ্যমে ভাসমান-পয়েন্ট মানগুলি উপস্থাপন করে। অতিরিক্তভাবে, হেক্সাডেসিমেল স্বরলিপিটি সংশ্লিষ্ট ধরণের ভাসমান-পয়েন্ট বিন্যাসে অন্তর্নিহিত বিটগুলি সরাসরি নির্দিষ্ট করতে ব্যবহার করা যেতে পারে। ভাসমান-পয়েন্ট ধ্রুবকগুলির নিম্নলিখিত সীমাবদ্ধতা রয়েছে:

• (C1) যদি অ-হেক্সাডেসিমেল স্বরলিপি ব্যবহার করা হয়, তাহলে is_wellformed(float_literal, float_type) ।
• (C2) যদি হেক্সাডেসিমেল নোটেশন ব্যবহার করা হয়, size(hexadecimal_digits) = num_bits(float_type) / 4 ।

ComplexConstant ::= ComplexLiteral ':' ComplexType
ComplexLiteral  ::= '(' RealPart ',' ImaginaryPart ')'
RealPart        ::= FloatLiteral
ImaginaryPart   ::= FloatLiteral

জটিল ধ্রুবকগুলি একটি বাস্তব অংশ (প্রথমে আসে) এবং একটি কাল্পনিক অংশ (দ্বিতীয়তে আসে) এর তালিকা ব্যবহার করে জটিল মানগুলি উপস্থাপন করে। উদাহরণস্বরূপ, (1.0, 0.0) : complex<f32> 1.0 + 0.0i প্রতিনিধিত্ব করে, এবং (0.0, 1.0) : complex<f32> 0.0 + 1.0i প্রতিনিধিত্ব করে। এই অংশগুলি মেমরিতে যে ক্রমে সংরক্ষণ করা হয় তা বাস্তবায়ন-সংজ্ঞায়িত। জটিল ধ্রুবকগুলির নিম্নলিখিত সীমাবদ্ধতা রয়েছে:

• (C1) is_wellformed(real_part, complex_element_type(complex_type)) ।
• (C2) is_wellformed(imaginary_part, complex_element_type(complex_type)) ।

TensorConstant ::= TensorLiteral ':' TensorType
TensorLiteral  ::= 'dense' '<' (DenseLiteral | ElementLiteral) '>'
DenseLiteral   ::= DenseDimension | DenseElements
DenseDimension ::= '[' [DenseLiteral {',' DenseLiteral}] ']'
DenseElements  ::= [ElementLiteral {',' ElementLiteral}]
ElementLiteral ::= BooleanLiteral | IntegerLiteral | FloatLiteral | ComplexLiteral

টেনসর ধ্রুবক NumPy নোটেশনের মাধ্যমে নির্দিষ্ট নেস্টেড তালিকা ব্যবহার করে টেনসর মান উপস্থাপন করে। উদাহরণস্বরূপ, dense<[[1, 2, 3], [4, 5, 6]]> : tensor<2x3xi32> সূচক থেকে উপাদানগুলিতে নিম্নলিখিত ম্যাপিং সহ একটি টেনসর মান উপস্থাপন করে: {0, 0} => 1 , {0, 1} => 2 , {0, 2} => 3 , {1, 0} => 4 , {1, 1} => 5 , {1, 2} => 6 । এই উপাদানগুলিকে মেমরিতে যে ক্রমে সংরক্ষণ করা হয় তা বাস্তবায়ন-সংজ্ঞায়িত। টেনসর ধ্রুবকগুলির নিম্নলিখিত সীমাবদ্ধতা রয়েছে:

• (C1) has_syntax(tensor_literal, element_type(tensor_type)) , যেখানে:
  • has_syntax(element_literal: Syntax, element_type: Type) = is_wellformed(element_literal, type) .
  • has_syntax(tensor_literal: List, element_type: Type) = has_syntax(tensor_literal..., element_type) .
• (C2) has_shape(tensor_literal, shape(tensor_type)) , যেখানে:
  • has_shape(element_literal: Syntax, []) = true .
  • has_shape(tensor_literal: List, shape: List) = size(tensor_literal) = shape[0] and has_shape(tensor_literal..., shape[1:]) ।
  • অন্যথায়, false ।

QuantizedTensorConstant ::= QuantizedTensorLiteral ':' QuantizedTensorType
QuantizedTensorLiteral  ::= 'dense' '<' (DenseLiteral | ElementLiteral) '>'

কোয়ান্টাইজড টেনসর ধ্রুবকগুলি টেনসর ধ্রুবকের মতো একই স্বরলিপি ব্যবহার করে কোয়ান্টাইজড টেনসর মানগুলি উপস্থাপন করে, যেখানে উপাদানগুলি তাদের স্টোরেজ ধরণের ধ্রুবক হিসাবে নির্দিষ্ট করা হয়। কোয়ান্টাইজড টেনসর ধ্রুবকগুলির নিম্নলিখিত সীমাবদ্ধতা রয়েছে:

• (C1) has_syntax(quantized_tensor_literal, storage_type(quantized_tensor_type)) ।
• (C2) has_shape(quantized_tensor_literal, shape(quantized_tensor_type)) .

StringConstant  ::= StringLiteral
StringLiteral   ::= '"' {stringCharacter | escapeSequence} '"'
stringCharacter ::= all ASCII characters except '\00', '\01', ... '\1f' and '"'
escapeSequence  ::= '\' ('"' | '\' | 'n' | 't' | (hexadecimalDigit hexadecimalDigit))

স্ট্রিং লিটারেলগুলিতে ASCII অক্ষর এবং এস্কেপ সিকোয়েন্স ব্যবহার করে নির্দিষ্ট বাইট থাকে। এগুলি এনকোডিং-অ্যাগনস্টিক, তাই এই বাইটের ব্যাখ্যা বাস্তবায়ন-সংজ্ঞায়িত। স্ট্রিং লিটারেলগুলিতে string টাইপ থাকে।

অপ্স

পেটের পেশী

শব্দার্থবিদ্যা

operand টেনসরের উপর এলিমেন্ট-ভিত্তিক অ্যাবস অপারেশন করে এবং একটি result টেনসর তৈরি করে। এলিমেন্টের ধরণের উপর নির্ভর করে, নিম্নলিখিত কাজগুলি করে:

• স্বাক্ষরিত পূর্ণসংখ্যার জন্য: পূর্ণসংখ্যা মডুলাস।
• ভাসমানদের জন্য: IEEE-754 থেকে abs ।
• জটিল সংখ্যার জন্য: জটিল মডুলাস।
• কোয়ান্টাইজড প্রকারের জন্য: dequantize_op_quantize(abs, operand, type(result)) ।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) shape(result) = shape(operand) ।
• (C2) baseline_element_type(result) এভাবে সংজ্ঞায়িত করা হয়েছে:
  • যদি is_complex( complex_element_type(element_type(operand)) is_complex(operand) ।
  • অন্যথায় baseline_element_type(operand) ।

উদাহরণ

// %operand: [-2, 0, 2]
%result = "stablehlo.abs"(%operand) : (tensor<3xi32>) -> tensor<3xi32>
// %result: [2, 0, 2]

আরও উদাহরণ

যোগ করুন

শব্দার্থবিদ্যা

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

• বুলিয়ানদের জন্য: লজিক্যাল OR।
• পূর্ণসংখ্যার জন্য: পূর্ণসংখ্যা যোগ।
• ফ্লোটের জন্য: IEEE-754 থেকে addition ।
• জটিল সংখ্যার জন্য: জটিল যোগ।
• কোয়ান্টাইজড প্রকারের জন্য: dequantize_op_quantize(add, lhs, rhs, type(result)) ।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• যদি অপারেশনটি অ-কোয়ান্টাইজড টেনসর ব্যবহার করে:
  • (C1) type(lhs) = type(rhs) = type(result) ।
• যদি অপারেশনটি কোয়ান্টাইজড টেনসর ব্যবহার করে:
  • (C2) is_quantized(lhs) and is_quantized(rhs) and is_quantized(result) ।
  • (C3) storage_type(lhs) = storage_type(rhs) = storage_type(result) .
  • (C4) expressed_type(lhs) = expressed_type(rhs) = expressed_type(result) .
  • (C5) (is_per_axis_quantized(lhs) or is_per_axis_quantized(rhs)) = is_per_axis_quantized(result)
  • (C6) যদি is_per_axis_quantized(lhs) হয়, তাহলে quantization_dimension(lhs) = quantization_dimension(result) ।
  • (C7) যদি is_per_axis_quantized(rhs) হয়, তাহলে quantization_dimension(rhs) = quantization_dimension(result) ।

উদাহরণ

// %lhs: [[1, 2], [3, 4]]
// %rhs: [[5, 6], [7, 8]]
%result = "stablehlo.add"(%lhs, %rhs) : (tensor<2x2xi32>, tensor<2x2xi32>) -> tensor<2x2xi32>
// %result: [[6, 8], [10, 12]]

আরও উদাহরণ

সর্বোপরি

শব্দার্থবিদ্যা

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

ইনপুট

আউটপুট

উদাহরণ

// %input0: !stablehlo.token
// %input1: !stablehlo.token
%result = "stablehlo.after_all"(%input0, %input1) : (!stablehlo.token, !stablehlo.token) -> !stablehlo.token

আরও উদাহরণ

সকল_সংগ্রহ

শব্দার্থবিদ্যা

StableHLO প্রক্রিয়া গ্রিডের প্রতিটি প্রক্রিয়া গোষ্ঠীর মধ্যে, all_gather_dim বরাবর প্রতিটি প্রক্রিয়া থেকে operands টেনসরের মানগুলিকে একত্রিত করে এবং results টেনসর তৈরি করে।

এই অপারেশনটি StableHLO প্রক্রিয়া গ্রিডকে process_groups এ বিভক্ত করে যা নিম্নরূপ সংজ্ঞায়িত করা হয়েছে:

• channel_id <= 0 and use_global_device_ids = false হলে cross_replica(replica_groups) ।
• channel_id > 0 and use_global_device_ids = false হলে cross_replica_and_partition(replica_groups) ।
• যদি channel_id > 0 and use_global_device_ids = true তাহলে flattened_ids(replica_groups) ।

এরপর, প্রতিটি process_group মধ্যে:

• operands...@receiver = [operand@sender for sender in process_group] process_group এ থাকা সকল receiver জন্য।
• results...@process = concatenate(operands...@process, all_gather_dim) process_group এর সকল process জন্য।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) 0 <= all_gather_dim < rank(operands...) .
• (C2) is_unique(replica_groups) ।
• (C3) size(replica_groups) এভাবে সংজ্ঞায়িত করা হয়েছে:
  • যদি cross_replica ব্যবহার করা হয়, তাহলে num_replicas
  • যদি cross_replica_and_partition ব্যবহার করা হয়, তাহলে num_replicas
  • যদি flattened_ids ব্যবহার করা হয়, তাহলে num_processes ।
• (C4) 0 <= replica_groups < size(replica_groups) .
• (C5) যদি use_global_device_ids = true , তাহলে channel_id > 0 ।
• (C6) type(results...) = type(operands...) ব্যতীত:
  • dim(results..., all_gather_dim) = dim(operands..., all_gather_dim) * dim(process_groups, 1) .

উদাহরণ

// num_replicas: 2
// num_partitions: 1
// %operand0@(0, 0): [[1, 2], [3, 4]]
// %operand0@(1, 0): [[5, 6], [7, 8]]
// %operand1@(0, 0): [[11, 12], [13, 14]]
// %operand1@(1, 0): [[15, 16], [17, 18]]
%result:2 = "stablehlo.all_gather"(%operand0, %operand1) {
  all_gather_dim = 1 : i64,
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>,
  // channel_id = 0
  channel_handle = #stablehlo.channel_handle<handle = 0, type = 0>
  // use_global_device_ids = false
} : (tensor<2x2xi64>, tensor<2x2xi64>) -> (tensor<2x4xi64>, tensor<2x4xi64>)
// %result0@(0, 0): [[1, 2, 5, 6], [3, 4, 7, 8]]
// %result0@(1, 0): [[1, 2, 5, 6], [3, 4, 7, 8]]
// %result1@(0, 0): [[11, 12, 15, 16], [13, 14, 17, 18]]
// %result1@(1, 0): [[11, 12, 15, 16], [13, 14, 17, 18]]

আরও উদাহরণ

সব_হ্রাস

শব্দার্থবিদ্যা

StableHLO প্রক্রিয়া গ্রিডের প্রতিটি প্রক্রিয়া গোষ্ঠীর মধ্যে, প্রতিটি প্রক্রিয়া থেকে operands এবং টেনসরের মানের উপর একটি হ্রাস ফাংশন computation প্রয়োগ করে এবং results টেনসর তৈরি করে।

এই অপারেশনটি StableHLO প্রক্রিয়া গ্রিডকে process_groups এ বিভক্ত করে যা নিম্নরূপ সংজ্ঞায়িত করা হয়েছে:

• channel_id <= 0 and use_global_device_ids = false হলে cross_replica(replica_groups) ।
• channel_id > 0 and use_global_device_ids = false হলে cross_replica_and_partition(replica_groups) ।
• যদি channel_id > 0 and use_global_device_ids = true তাহলে flattened_ids(replica_groups) ।

এরপর, প্রতিটি process_group মধ্যে:

• results...@process[result_index] = exec(schedule) কিছু বাইনারি ট্রি schedule জন্য যেখানে:
  • exec(node) = computation(exec(node.left), exec(node.right)) .
  • exec(leaf) = leaf.value .
• schedule হল একটি বাস্তবায়ন-সংজ্ঞায়িত বাইনারি ট্রি যার ইন-অর্ডার ট্র্যাভার্সাল হল to_destination_type(operands...@process_group...[result_index], type(func_inputs(computation)[0])) ।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) is_unique(replica_groups) ।
• (C2) size(replica_groups) এভাবে সংজ্ঞায়িত করা হয়েছে:
  • যদি cross_replica ব্যবহার করা হয়, তাহলে num_replicas
  • যদি cross_replica_and_partition ব্যবহার করা হয়, তাহলে num_replicas
  • যদি flattened_ids ব্যবহার করা হয়, তাহলে num_processes ।
• (C3) 0 <= replica_groups < size(replica_groups) .
• (C4) যদি use_global_device_ids = true , তাহলে channel_id > 0 ।
• (C5) computation ধরণ (tensor<E>, tensor<E>) -> (tensor<E>) যেখানে is_promotable(element_type(operand), E) ।
• (C6) shape(results...) = shape(operands...) .
• (C7) element_type(results...) = E .

উদাহরণ

// num_replicas: 2
// num_partitions: 1
// %operand0@(0, 0): [1, 2, 3, 4]
// %operand0@(1, 0): [5, 6, 7, 8]
// %operand1@(0, 0): [9, 10, 11, 12]
// %operand1@(1, 0): [13, 14, 15, 16]
%result:2 = "stablehlo.all_reduce"(%operand0, %operand0) ({
  ^bb0(%arg0: tensor<i64>, %arg1: tensor<i64>):
    %0 = "stablehlo.add"(%arg0, %arg1) : (tensor<i64>, tensor<i64>) -> tensor<i64>
    "stablehlo.return"(%0) : (tensor<i64>) -> ()
}) {
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>,
  // channel_id = 0
  channel_handle = #stablehlo.channel_handle<handle = 0, type = 0>
  // use_global_device_ids = false
} : (tensor<4xi64>, tensor<4xi64>) -> (tensor<4xi64>, tensor<4xi64>)
// %result0@(0, 0): [6, 8, 10, 12]
// %result0@(1, 0): [6, 8, 10, 12]
// %result1@(0, 0): [22, 24, 26, 28]
// %result1@(1, 0): [22, 24, 26, 28]

আরও উদাহরণ

সকলের_জন্য_সকল

শব্দার্থবিদ্যা

StableHLO প্রসেস গ্রিডের প্রতিটি প্রসেস গ্রুপের মধ্যে, split_dimension বরাবর operands টেনসরের মানগুলিকে অংশে বিভক্ত করে, প্রসেসগুলির মধ্যে বিভক্ত অংশগুলিকে ছড়িয়ে দেয়, concat_dimension বরাবর বিক্ষিপ্ত অংশগুলিকে সংযুক্ত করে এবং results টেনসর তৈরি করে। এই অপারেশনটি StableHLO প্রসেস গ্রিডকে process_groups এ বিভক্ত করে যা নিম্নরূপ সংজ্ঞায়িত করা হয়েছে:

• channel_id <= 0 হলে cross_replica(replica_groups) ।
• channel_id > 0 হলে cross_partition(replica_groups) ।

এরপর, প্রতিটি process_group মধ্যে:

• split_parts...@sender = split(operands...@sender, split_count, split_dimension) process_group এ সকল sender জন্য split(operands...@sender, split_count, split_dimension)।
• scattered_parts...@receiver = [split_parts...@sender[receiver_index] for sender in process_group] যেখানে receiver_index = process_group.index(receiver) .
• results...@process = concatenate(scattered_parts...@process, concat_dimension) ।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) 0 <= split_dimension < rank(operands...) .
• (C2) dim(operands..., split_dimension) % split_count = 0 .
• (C3) 0 <= concat_dimension < rank(operands...) .
• (C4) 0 < split_count .
• (C5) is_unique(replica_groups) ।
• (C6) size(replica_groups) এভাবে সংজ্ঞায়িত করা হয়েছে:
  • যদি cross_replica ব্যবহার করা হয়, তাহলে num_replicas
  • যদি cross_partition ব্যবহার করা হয়, তাহলে num_partitions ।
• (C7) 0 <= replica_groups < size(replica_groups) .
• (C8) dim(replica_groups, 1) = split_count .
• (C9) type(results...) = type(operands...) ব্যতীত, যদি split_dimension != concat_dimension :
  • dim(results..., split_dimension) = dim(operands..., split_dimension) / split_count
  • dim(results..., concat_dimension) = dim(operands..., concat_dimension) * split_count .

উদাহরণ

// num_replicas: 2
// num_partitions: 1
// %operand1@(0, 0): [[1, 2, 3, 4],
//                    [5, 6, 7, 8]]
// %operand1@(1, 0): [[9, 10, 11, 12],
//                    [13, 14, 15, 16]]
// %operand2@(0, 0): [[17, 18, 19, 20],
//                    [21, 22, 23, 24]]
// %operand2@(1, 0): [[25, 26, 27, 28],
//                    [29, 30, 31, 32]]
%result:2 = "stablehlo.all_to_all"(%operand1, %operand2) {
  split_dimension = 1 : i64,
  concat_dimension = 0 : i64,
  split_count = 2 : i64,
  replica_groups = dense<[[0, 1]]> : tensor<1x2xi64>
  // channel_id = 0
} : (tensor<2x4xi64>, tensor<2x4xi64>) -> (tensor<4x2xi64>, tensor<4x2xi64>)
// %result#0@(0, 0): [[1, 2], [5, 6], [9, 10], [13, 14]]
// %result#0@(1, 0): [[3, 4], [7, 8], [11, 12], [15, 16]]
// %result#1@(0, 0): [[17, 18], [21, 22], [25, 26], [29, 30]]
// %result#1@(1, 0): [[19, 20], [23, 24], [27, 28], [31, 32]]

আরও উদাহরণ

এবং

শব্দার্থবিদ্যা

দুটি টেনসর lhs এবং rhs এর উপাদান-ভিত্তিক AND সম্পাদন করে এবং একটি result টেনসর তৈরি করে। উপাদানের ধরণের উপর নির্ভর করে, নিম্নলিখিতগুলি করে:

• বুলিয়ানদের জন্য: লজিক্যাল AND।
• পূর্ণসংখ্যার জন্য: বিটওয়াইজ AND।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) type(lhs) = type(rhs) = type(result) ।

উদাহরণ

// %lhs: [[1, 2], [3, 4]]
// %rhs: [[5, 6], [7, 8]]
%result = "stablehlo.and"(%lhs, %rhs) : (tensor<2x2xi32>, tensor<2x2xi32>) -> tensor<2x2xi32>
// %result: [[1, 2], [3, 0]]

আরও উদাহরণ

atan2 সম্পর্কে

শব্দার্থবিদ্যা

lhs এবং rhs টেনসরের উপর উপাদান-ভিত্তিক atan2 অপারেশন সম্পাদন করে এবং একটি result টেনসর তৈরি করে। উপাদানের ধরণের উপর নির্ভর করে, নিম্নলিখিতগুলি করে:

• ফ্লোটের জন্য: IEEE-754 থেকে atan2 ।
• জটিল সংখ্যার জন্য: জটিল atan2।
• কোয়ান্টাইজড প্রকারের জন্য: dequantize_op_quantize(atan2, lhs, rhs, type(result)) ।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) baseline_type(lhs) = baseline_type(rhs) = baseline_type(result) .

উদাহরণ

// %lhs: [0.0, 1.0, -1.0]
// %rhs: [0.0, 0.0, 0.0]
%result = "stablehlo.atan2"(%lhs, %rhs) : (tensor<3xf64>, tensor<3xf64>) -> tensor<3xf64>
// %result: [0.0, 1.57079637, -1.57079637] // [0.0, pi/2, -pi/2]

আরও উদাহরণ

ব্যাচ_নর্ম_গ্র্যাড

শব্দার্থবিদ্যা

grad_output থেকে batch_norm_training এর ব্যাকপ্রোপাগেটিং এর বেশ কয়েকটি ইনপুটের গ্রেডিয়েন্ট গণনা করে এবং grad_operand , grad_scale এবং grad_offset টেনসর তৈরি করে। আরও আনুষ্ঠানিকভাবে, এই অপারেশনটিকে পাইথন সিনট্যাক্স ব্যবহার করে বিদ্যমান StableHLO অপারেশনের একটি পচন হিসাবে নিম্নরূপ প্রকাশ করা যেতে পারে:

def compute_sum(operand, feature_index):
  (sum,) = reduce(
      inputs=[operand],
      init_values=[constant(0, element_type(operand))],
      dimensions=[i for i in range(rank(operand)) if i != feature_index],
      body=lambda x, y: add(x, y))
  return sum

def compute_mean(operand, feature_index):
  sum = compute_sum(operand, feature_index)
  divisor = constant(size(operand) / dim(operand, feature_index),
                     element_type(operand))
  divisor_bcast = broadcast_in_dim(divisor, [], type(sum))
  return divide(sum, divisor_bcast)

def batch_norm_grad(operand, scale, mean, variance, grad_output, epsilon, feature_index):
  # Broadcast inputs to type(operand)
  scale_bcast = broadcast_in_dim(scale, [feature_index], type(operand))
  mean_bcast = broadcast_in_dim(mean, [feature_index], type(operand))
  variance_bcast = broadcast_in_dim(variance, [feature_index], type(operand))
  epsilon_bcast = broadcast_in_dim(constant(epsilon, element_type(operand)), [],
                                   type(operand))

  # Perform normalization using the provided `mean` and `variance`
  # Intermediate values will be useful for computing gradients
  centered_operand = subtract(operand, mean_bcast)
  stddev = sqrt(add(variance_bcast, epsilon_bcast))
  normalized_operand = divide(centered_operand, stddev)

  # Use the implementation from batchnorm_expander.cc in XLA
  # Temporary variables have exactly the same names as in the C++ code
  elements_per_feature = broadcast_in_dim(
      constant(divide(size(operand), dim(operand, feature_index)),
               element_type(grad_output)),
      [], type(operand))
  i1 = multiply(grad_output, elements_per_feature)
  i2 = broadcast_in_dim(
      compute_sum(grad_output, feature_index), [feature_index], type(operand))
  i3 = broadcast_in_dim(
      compute_sum(multiply(grad_output, centered_operand), feature_index),
      [feature_index], type(operand))
  i4 = multiply(i3, centered_operand)
  i5 = divide(i4, add(variance_bcast, epsilon_bcast))
  i6 = subtract(subtract(i1, i2), i5)

  grad_operand =
      multiply(divide(divide(scale_bcast, stddev), elements_per_feature), i6)
  grad_scale =
      compute_sum(multiply(grad_output, normalized_operand), feature_index)
  grad_offset = compute_sum(grad_output, feature_index)

  return grad_operand, grad_scale, grad_offset

কোয়ান্টাইজড প্রকারের জন্য, dequantize_batch_norm_grad_or_training_quantize(lambda operand, scale, mean, variance, grad_output: batch_norm_grad(operand, scale, mean, variance, grad_output, epsilon, feature_index), operand, scale, mean, variance, grad_output, type(grad_operand), type(grad_scale), type(feature_index)) ।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) 0 <= feature_index < rank(operand) .
• (C2) operand , scale , mean , variance , grad_output , grad_operand , grad_scale এবং grad_offset baseline_element_type একই।
• (C3) operand , grad_output এবং grad_operand আকৃতি একই।
• (C4) scale , mean , variance , grad_scale এবং grad_offset আকৃতি একই।
• (C5) size(scale) = dim(operand, feature_index) .

উদাহরণ

// %operand: [
//            [[1.0, 2.0], [3.0, 4.0]],
//            [[3.0, 4.0], [1.0, 2.0]]
//           ]
// %scale: [1.0, 1.0]
// %mean: [2.0, 3.0]
// %variance: [1.0, 1.0]
// %grad_output: [
//                [[0.1, 0.1], [0.1, 0.1]],
//                [[0.1, 0.1], [0.1, 0.1]]
//               ]
%grad_operand, %grad_scale, %grad_offset =
"stablehlo.batch_norm_grad"(%operand, %scale, %mean, %variance, %grad_output) {
  epsilon = 0.0 : f32,
  feature_index = 2 : i64
} : (tensor<2x2x2xf64>, tensor<2xf64>, tensor<2xf64>, tensor<2xf64>,
     tensor<2x2x2xf64>) -> (tensor<2x2x2xf64>, tensor<2xf64>, tensor<2xf64>)
// %grad_operand: [
//                 [[0.0, 0.0], [0.0, 0.0]],
//                 [[0.0, 0.0], [0.0, 0.0]]
//                ]
// %grad_scale:  [0.0, 0.0]
// %grad_offset: [0.4, 0.4]

ব্যাচ_নর্ম_ইনফারেন্স

শব্দার্থবিদ্যা

feature_index মাত্রা ব্যতীত সকল মাত্রায় operand টেনসরকে স্বাভাবিক করে তোলে এবং একটি result টেনসর তৈরি করে। আরও আনুষ্ঠানিকভাবে, এই অপারেশনটিকে পাইথন সিনট্যাক্স ব্যবহার করে বিদ্যমান StableHLO অপারেশনগুলির একটি বিচ্ছেদ হিসাবে নিম্নরূপ প্রকাশ করা যেতে পারে:

def batch_norm_inference(operand, scale, offset, mean, variance, epsilon, feature_index):
  # Broadcast inputs to shape(operand)
  scale_bcast = broadcast_in_dim(scale, [feature_index], type(operand))
  offset_bcast = broadcast_in_dim(offset, [feature_index], type(operand))
  mean_bcast = broadcast_in_dim(mean, [feature_index], type(operand))
  variance_bcast = broadcast_in_dim(variance, [feature_index], type(operand))
  epsilon_bcast = broadcast_in_dim(constant(epsilon, element_type(operand)), [],
                                   type(operand))

  # Perform normalization using the provided `mean` and `variance` instead of
  # computing them like `batch_norm_training` does.
  centered_operand = subtract(operand, mean_bcast)
  stddev = sqrt(add(variance_bcast, epsilon_bcast))
  normalized_operand = divide(centered_operand, stddev)
  return add(multiply(scale_bcast, normalized_operand), offset_bcast)

কোয়ান্টাইজড প্রকারের জন্য, dequantize_op_quantize(lambda operand, scale, offset, mean, variance: batch_norm_inference(operand, scale, offset, mean, variance, epsilon, feature_index), operand, scale, offset, mean, variance, type(result)) সম্পাদন করে।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) 0 <= feature_index < rank(operand) .
• (C2) operand , scale , offset , mean , variance এবং result baseline_element_type একই।
• (C3) size(scale) = dim(operand, feature_index) .
• (C4) size(offset) = dim(operand, feature_index) ।
• (C5) size(mean) = dim(operand, feature_index) ।
• (C6) size(variance) = dim(operand, feature_index) ।
• (C7) baseline_type(operand) = baseline_type(result) .

উদাহরণ

// %operand: [
//            [[1.0, 2.0], [3.0, 4.0]],
//            [[3.0, 4.0], [1.0, 2.0]]
//           ]
// %scale: [1.0, 1.0]
// %offset: [1.0, 1.0]
// %mean: [2.0, 3.0]
// %variance: [1.0, 1.0]
%result = "stablehlo.batch_norm_inference"(%operand, %scale, %offset, %mean, %variance) {
  epsilon = 0.0 : f32,
  feature_index = 2 : i64
} : (tensor<2x2x2xf64>, tensor<2xf64>, tensor<2xf64>, tensor<2xf64>, tensor<2xf64>) -> tensor<2x2x2xf64>
// %result: [
//           [[0.0, 0.0], [2.0, 2.0]],
//           [[2.0, 2.0], [0.0, 0.0]]
//          ]

ব্যাচ_নর্ম_ট্রেনিং

শব্দার্থবিদ্যা

feature_index মাত্রা ব্যতীত সকল মাত্রার গড় এবং ভ্যারিয়েন্স গণনা করে এবং operand টেনসরকে স্বাভাবিক করে তোলে যা output , batch_mean এবং batch_var টেনসর তৈরি করে। আরও আনুষ্ঠানিকভাবে, এই অপারেশনটিকে পাইথন সিনট্যাক্স ব্যবহার করে বিদ্যমান StableHLO অপারেশনের একটি পচন হিসাবে নিম্নরূপ প্রকাশ করা যেতে পারে:

def compute_mean(operand, feature_index):
  (sum,) = reduce(
      inputs=[operand],
      init_values=[constant(0, element_type(operand))],
      dimensions=[i for i in range(rank(operand)) if i != feature_index],
      body=lambda x, y: add(x, y))
  divisor = constant(size(operand) / dim(operand, feature_index),
                     element_type(operand))
  divisor_bcast = broadcast_in_dim(divisor, [], type(sum))
  return divide(sum, divisor_bcast)

def compute_variance(operand, feature_index):
  mean = compute_mean(operand, feature_index)
  mean_bcast = broadcast_in_dim(mean, [feature_index], type(operand))
  centered_operand = subtract(operand, mean_bcast)
  return compute_mean(mul(centered_operand, centered_operand), feature_index)

def batch_norm_training(operand, scale, offset, epsilon, feature_index):
  mean = compute_mean(operand, feature_index)
  variance = compute_variance(operand, feature_index)
  return batch_norm_inference(operand, scale, offset, mean, variance, epsilon,
                              feature_index),
         mean, variance

কোয়ান্টাইজড ধরণের জন্য, dequantize_batch_norm_grad_or_training_quantize(lambda operand, scale, offset: batch_norm_training(operand, scale, offset, epsilon, feature_index), operand, scale, offset, type(output), type(batch_mean), type(batch_var)) সম্পাদন করে।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) 0 <= feature_index < rank(operand) .
• (C2) operand , scale , offset , batch_mean , batch_var এবং output একই baseline_element_type ।
• (C3) size(scale) = dim(operand, feature_index) .
• (C4) size(offset) = dim(operand, feature_index) ।
• (C5) size(batch_mean) = dim(operand, feature_index) .
• (C6) size(batch_var) = dim(operand, feature_index) .
• (C7) baseline_type(output) = baseline_type(operand) ।

উদাহরণ

// %operand: [
//            [[1.0, 2.0], [3.0, 4.0]],
//            [[3.0, 4.0], [1.0, 2.0]]
//           ]
// %scale: [1.0, 1.0]
// %offset: [1.0, 1.0]
%output, %batch_mean, %batch_var = "stablehlo.batch_norm_training"(%operand, %scale, %offset) {
  epsilon = 0.0 : f32,
  feature_index = 2 : i64
} : (tensor<2x2x2xf64>, tensor<2xf64>, tensor<2xf64>) ->
    (tensor<2x2x2xf64>, tensor<2xf64>, tensor<2xf64>)
// %output: [
//           [[0.0, 0.0], [2.0, 2.0]],
//           [[2.0, 2.0], [0.0, 0.0]]
//          ]
// %batch_mean: [2.0, 3.0]
// %batch_var: [1.0, 1.0]

বিটকাস্ট_কনভার্ট

শব্দার্থবিদ্যা

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

আরও আনুষ্ঠানিকভাবে, E = element_type(operand) , E' = element_type(result) , এবং R = rank(operand) দেওয়া হয়েছে:

• যদি num_bits(E') < num_bits(E) , bits(result[i0, ..., iR-1, :]) = bits(operand[i0, ..., iR-1])
• যদি num_bits(E') > num_bits(E) , bits(result[i0, ..., iR-2]) = bits(operand[i0, ..., iR-2, :])
• যদি num_bits(E') = num_bits(E) , bits(result[i0, ..., iR-1]) = bits(operand[i0, ..., iR-1])

bits returns in-memory representation of a given value, and its behavior is implementation-defined because the exact representation of tensors is implementation-defined, and the exact representation of element types is implementation-defined as well.

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) Given E = is_quantized(operand) ? storage_type(operand) : element_type(operand) , E' = is_quantized(result) ? storage_type(result) : element_type(result) , and R = rank(operand) :
  • If num_bits(E') = num_bits(E) , shape(result) = shape(operand) .
  • If num_bits(E') < num_bits(E) :
  • rank(result) = R + 1 .
  • dim(result, i) = dim(operand, i) for all 0 <= i < R .
  • dim(result, R) * num_bits(E') = num_bits(E) .
  • If num_bits(E') > num_bits(E) :
  • rank(result) = R - 1 .
  • dim(result, i) = dim(operand, i) for all 0 <= i < R .
  • dim(operand, R - 1) * num_bits(E) = num_bits(E') .
• (C2) If is_complex(operand) or is_complex(result) , then is_complex(operand) and is_complex(result) .

উদাহরণ

// %operand: 0x0123456789ABCDEF
%result = "stablehlo.bitcast_convert"(%operand) : (tensor<f64>) -> tensor<4xf16>
// %result: [0xCDEF, 0x89AB, 0x4567, 0x0123] // little-endian representation

আরও উদাহরণ

broadcast_in_dim

শব্দার্থবিদ্যা

Expands the dimensions and/or rank of an input tensor by duplicating the data in the operand tensor and produces a result tensor. More formally, result[result_index] = operand[operand_index] where for all d in axes(operand) :

• operand_index[d] = 0 if dim(operand, d) = 1 .
• operand_index[d] = result_index[broadcast_dimensions[d]] otherwise.

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) element_type(result) is given by:
  • element_type(operand) , if !is_per_axis_quantized(operand) .
  • element_type(operand) except that quantization_dimension(operand) , scales(operand) , and zero_points(operand) may differ from quantization_dimension(result) , scales(result) , and zero_points(result) resp., otherwise.
• (C2) size(broadcast_dimensions) = rank(operand) .
• (C3) 0 <= broadcast_dimensions < rank(result) .
• (C4) is_unique(broadcast_dimensions) .
• (C5) For all d in axes(operand) :
  • dim(operand, d) = 1 or
  • dim(operand, d) = dim(result, broadcast_dimensions[d]) .
• (C6) If is_per_axis_quantized(result) :
  • quantization_dimension(result) = broadcast_dimensions[quantization_dimension(operand)] .
  • If dim(operand, quantization_dimension(operand)) = 1 , then scales(result)[i] = scales(operand)[0] and zero_points(result)[i] = zero_points(operand)[0] for i in range(dim(result, quantization_dimension(result))) .

উদাহরণ

// %operand: [
//            [1, 2, 3]
//           ]
%result = "stablehlo.broadcast_in_dim"(%operand) {
  broadcast_dimensions = array<i64: 2, 1>
} : (tensor<1x3xi32>) -> tensor<2x3x2xi32>
// %result: [
//            [
//             [1, 1],
//             [2, 2],
//             [3, 3]
//            ],
//            [
//             [1, 1],
//             [2, 2],
//             [3, 3]
//            ]
//          ]

আরও উদাহরণ

মামলা

শব্দার্থবিদ্যা

Produces the output from executing exactly one function from branches depending on the value of index . More formally, result = selected_branch() where:

• selected_branch = branches[index] if 0 <= index < size(branches) .
• selected_branch = branches[-1] otherwise.

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) 0 < size(branches) .
• (C2) input_types(branches...) = [] .
• (C3) same(output_types(branches...)) .
• (C4) type(results...) = output_types(branches[0]) .

উদাহরণ

// %index: -1
// %result_branch0: [0, 0]
// %result_branch1: [1, 1]
%result0, %result1 = "stablehlo.case"(%index) ({
  "stablehlo.return"(%result_branch0, %result_branch0) : (tensor<2xi64>, tensor<2xi64>) -> ()
}, {
  "stablehlo.return"(%result_branch1, %result_branch1) : (tensor<2xi64>, tensor<2xi64>) -> ()
}) : (tensor<i32>) -> (tensor<2xi64>, tensor<2xi64>)
// %result0: [1, 1]
// %result1: [1, 1]

আরও উদাহরণ

সিবিআরটি

শব্দার্থবিদ্যা

Performs element-wise cubic root operation on operand tensor and produces a result tensor. Depending on the element type, does the following:

• For floats: rootn(x, 3) from IEEE-754.
• For complex numbers: complex cubic root.
• For quantized types: dequantize_op_quantize(cbrt, operand, type(result))

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) baseline_type(operand) = baseline_type(result) .

উদাহরণ

// %operand: [0.0, 1.0, 8.0, 27.0]
%result = "stablehlo.cbrt"(%operand) : (tensor<4xf64>) -> tensor<4xf64>
// %result: [0.0, 1.0, 2.0, 3.0]

আরও উদাহরণ

ছাদ

শব্দার্থবিদ্যা

Performs element-wise ceil of operand tensor and produces a result tensor. Implements the roundToIntegralTowardPositive operation from the IEEE-754 specification. For quantized types, performs dequantize_op_quantize(ceil, operand, type(result)) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) baseline_type(operand) = baseline_type(result) .

উদাহরণ

// %operand: [-0.8166, -0.2530, 0.2530, 0.8166, 2.0]
%result = "stablehlo.ceil"(%operand) : (tensor<5xf32>) -> tensor<5xf32>
// %result: [-0.0, -0.0, 1.0, 1.0, 2.0]

আরও উদাহরণ

cholesky

শব্দার্থবিদ্যা

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

More formally, for all i in index_space(result) , result[i0, ..., iR-3, :, :] is a Cholesky decomposition of a[i0, ..., iR-3, :, :] , in the form of either of a lower-triangular (if lower is true ) or upper-triangular (if lower is false ) matrix. The output values in the opposite triangle, ie the strict upper triangle or strict lower triangle correspondingly, are implementation-defined.

If there exists i where the input matrix is not an Hermitian positive-definite matrix, then the behavior is undefined.

For quantized types, performs dequantize_op_quantize(lambda operand: cholesky(operand, lower), a, type(result)) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) baseline_type(a) = baseline_type(result) .
• (C2) 2 <= rank(a) .
• (C3) dim(a, -2) = dim(a, -1) .

উদাহরণ

// %a: [
//      [1.0, 2.0, 3.0],
//      [2.0, 20.0, 26.0],
//      [3.0, 26.0, 70.0]
//     ]
%result = "stablehlo.cholesky"(%a) {
  lower = true
} : (tensor<3x3xf32>) -> tensor<3x3xf64>
// %result: [
//           [1.0, 0.0, 0.0],
//           [2.0, 4.0, 0.0],
//           [3.0, 5.0, 6.0]
//          ]

ক্ল্যাম্প

শব্দার্থবিদ্যা

Clamps every element of the operand tensor between a minimum and maximum value and produces a result tensor. More formally, result[result_index] = minimum(maximum(operand[result_index], min_element), max_element) , where min_element = rank(min) = 0 ? min[] : min[result_index] , max_element = rank(max) = 0 ? max[] : max[result_index] . For quantized types, performs dequantize_op_quantize(clamp, min, operand, max, type(result)) .

Imposing an ordering on complex numbers involves surprising semantics, so in the future we are planning to remove support for complex numbers for this operation ( #560 ).

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) rank(min) = 0 or shape(min) = shape(operand) .
• (C2) rank(max) = 0 or shape(max) = shape(operand) .
• (C3) baseline_element_type(min) = baseline_element_type(operand) = baseline_element_type(max) .
• (C4) baseline_type(operand) = baseline_type(result) .

উদাহরণ

// %min: [5, 10, 15]
// %operand: [3, 13, 23]
// %max: [10, 15, 20]
%result = "stablehlo.clamp"(%min, %operand, %max) : (tensor<3xi32>, tensor<3xi32>, tensor<3xi32>) -> tensor<3xi32>
// %result: [5, 13, 20]

আরও উদাহরণ

collective_broadcast

শব্দার্থবিদ্যা

Within each process group in the StableHLO process grid, send the value of the operand tensor from the source process to the target processes and produce a result tensor.

The operation splits the StableHLO process grid into process_groups which is defined as follows:

• cross_replica(replica_groups) if channel_id <= 0 .
• cross_partition(replica_groups) if channel_id > 0 .

Afterwards, result@process is given by:

• operand@process_groups[i, 0] if there exists an i such that the process is in process_groups[i] .
• broadcast_in_dim(constant(is_quantized(result) ? quantize(0, element_type(result)) : 0, element_type(result)), [], type(result)) otherwise.

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) is_unique(replica_groups) .
• (C2) 0 <= replica_groups < N where N is defined as:
  • num_replicas if cross_replica is used.
  • num_partitions if cross_partition is used.
• (C3) type(result) = type(operand) .

উদাহরণ

// num_replicas: 4
// num_partitions: 1
// %operand@(0, 0): [[1, 2]]
// %operand@(1, 0): [[3, 4]]
// %operand@(2, 0): [[5, 6]]
// %operand@(3, 0): [[7, 8]]
%result = "stablehlo.collective_broadcast"(%operand) {
  replica_groups = dense<[[2, 1]]> : tensor<1x2xi64>,
  channel_handle = #stablehlo.channel_handle<handle = 0, type = 0>
} : (tensor1x2xi64>) -> tensor<1x2xi64>
// %result@(0, 0): [[0, 0]]
// %result@(1, 0): [[5, 6]]
// %result@(2, 0): [[5, 6]]
// %result@(3, 0): [[0, 0]]

collective_permute

শব্দার্থবিদ্যা

Within each process group in the StableHLO process grid, sends the value of the operand tensor from the source process to the target process and produces a result tensor.

The operation splits the StableHLO process grid into process_groups which is defined as follows:

• cross_replica(source_target_pairs) if channel_id <= 0 .
• cross_partition(source_target_pairs) if channel_id > 0 .

Afterwards, result@process is given by:

• operand@process_groups[i, 0] , if there exists an i such that process_groups[i, 1] = process .
• broadcast_in_dim(constant(is_quantized(result) ? quantize(0, element_type(result)) : 0, element_type(result)), [], type(result)) otherwise.

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) dim(source_target_pairs, 1) = 2 .
• (C2) is_unique(source_target_pairs[:, 0]) .
• (C3) is_unique(source_target_pairs[:, 1]) .
• (C4) 0 <= source_target_pairs < N , where N is defined as:
  • num_replicas if cross_replica is used.
  • num_partitions if cross_partition is used.
• (C5) type(result) = type(operand) .

উদাহরণ

// num_replicas: 3
// num_partitions: 1
// %operand@(0, 0): [[1, 2], [3, 4]]
// %operand@(1, 0): [[5, 6], [7, 8]]
// %operand@(2, 0): [[9, 10], [11, 12]]
%result = "stablehlo.collective_permute"(%operand) {
  source_target_pairs = dense<[[0, 1], [1, 2]]> : tensor<2x2xi64>,
  channel_handle = #stablehlo.channel_handle<handle = 0, type = 0>
} : (tensor<2x2xi64>) -> tensor<2x2xi64>
//
// %result@(0, 0): [[0, 0], [0, 0]]
// %result@(1, 0): [[1, 2], [3, 4]]
// %result@(2, 0): [[5, 6], [7, 8]]

আরও উদাহরণ

তুলনা করা

শব্দার্থবিদ্যা

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

The values of comparison_direction and compare_type have the following semantics:

For boolean and integer element types:

• EQ : lhs = rhs .
• NE : lhs != rhs .
• GE : lhs >= rhs .
• GT : lhs > rhs .
• LE : lhs <= rhs .
• LT : lhs < rhs .

For floating-point element types with compare_type = FLOAT , the op implements the following IEEE-754 operations:

• EQ : compareQuietEqual .
• NE : compareQuietNotEqual .
• GE : compareQuietGreaterEqual .
• GT : compareQuietGreater .
• LE : compareQuietLessEqual .
• LT : compareQuietLess .

For floating-point element types with compare_type = TOTALORDER , the op uses the combination of totalOrder and compareQuietEqual operations from IEEE-754.

For complex element types, lexicographic comparison of (real, imag) pairs is performed using the provided comparison_direction and compare_type . Imposing an ordering on complex numbers involves surprising semantics, so in the future we are planning to remove support for complex numbers when comparison_direction is GE , GT , LE or LT ( #560 ).

For quantized types. performs dequantize_compare(lhs, rhs, comparison_direction) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) baseline_element_type(lhs) = baseline_element_type(rhs) .
• (C2) shape(lhs) = shape(rhs) = shape(result) .
• (C3) compare_type is defined as:
  • SIGNED if is_signed_integer(element_type(lhs)) .
  • UNSIGNED if is_unsigned_integer(element_type(lhs)) or is_boolean(element_type(lhs)) .
  • FLOAT or TOTALORDER if is_float(element_type(lhs)) .
  • FLOAT if is_complex(element_type(lhs)) .

উদাহরণ

// %lhs: [1.0, 3.0]
// %rhs: [1.1, 2.9]
%result = "stablehlo.compare"(%lhs, %rhs) {
  comparison_direction = #stablehlo<comparison_direction LT>,
  compare_type = #stablehlo<comparison_type FLOAT>
} : (tensor<2xf32>, tensor<2xf32>) -> tensor<2xi1>
// %result: [true, false]

আরও উদাহরণ

জটিল

শব্দার্থবিদ্যা

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

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) type(lhs) = type(rhs) .
• (C2) shape(result) = shape(lhs) .
• (C3) element_type(result) has type complex<E> where E = element_type(lhs) .

উদাহরণ

// %lhs: [1.0, 3.0]
// %rhs: [2.0, 4.0]
%result = "stablehlo.complex"(%lhs, %rhs) : (tensor<2xf64>, tensor<2xf64>) -> tensor<2xcomplex<f64>>
// %result: [(1.0, 2.0), (3.0, 4.0)]

আরও উদাহরণ

যৌগিক

শব্দার্থবিদ্যা

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.

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) is_namespaced_op_name(name)
• (C2) is_defined_in_parent_scope(decomposition)
• (C3) types(inputs...) == input_types(decomposition)
• (C4) types(results...) == output_types(decomposition)

উদাহরণ

%results = "stablehlo.composite"(%input0, %input1) {
  name = "my_namespace.my_op",
  composite_attributes = {
    my_attribute = "my_value"
  },
  decomposition = @my_op,
  version = 1 : i32
} : (tensor<f32>, tensor<f32>) -> tensor<f32>

আরও উদাহরণ

সংযোজিত করা

শব্দার্থবিদ্যা

Concatenates inputs along dimension dimension in the same order as the given arguments and produces a result tensor. More formally, result[i0, ..., id, ..., iR-1] = inputs[k][i0, ..., kd, ..., iR-1] , where:

1. id = d0 + ... + dk-1 + kd .
2. d is equal to dimension , and d0 , ... are d th dimension sizes of inputs .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) same(element_type(inputs...)) .
• (C2) same(shape(inputs...)) except for dim(inputs..., dimension) .
• (C3) 0 < size(inputs) .
• (C4) 0 <= dimension < rank(inputs[0]) .
• (C5) element_type(result) = element_type(inputs[0]) .
• (C6) shape(result) = shape(inputs[0]) except for:
  • dim(result, dimension) = dim(inputs[0], dimension) + ... .

উদাহরণ

// %input0: [[1, 2], [3, 4], [5, 6]]
// %input1: [[7, 8]]
%result = "stablehlo.concatenate"(%input0, %input1) {
  dimension = 0 : i64
} : (tensor<3x2xi64>, tensor<1x2xi64>) -> tensor<4x2xi64>
// %result: [[1, 2], [3, 4], [5, 6], [7, 8]]

আরও উদাহরণ

ধ্রুবক

শব্দার্থবিদ্যা

Produces an output tensor from a constant value .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) type(value) = type(output) .

উদাহরণ

%output = "stablehlo.constant"() {
  value = dense<[[0.0, 1.0], [2.0, 3.0]]> : tensor<2x2xf32>
} : () -> tensor<2x2xf32>
// %output: [[0.0, 1.0], [2.0, 3.0]]

আরও উদাহরণ

রূপান্তর করুন

শব্দার্থবিদ্যা

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

For boolean-to-any-supported-type conversions, the value false is converted to zero, and the value true is converted to one. For any-supported-type-to-boolean conversions, a zero value is converted to false , and non-zero values are converted to true . See below for how this work for complex types.

For conversions involving integer-to-integer , integer-to-floating-point or floating-point-to-floating-point , if the source value can be exactly represented in the destination type, the result value is that exact representation. Otherwise, the behavior is TBD ( #180 ).

For conversions involving floating-point-to-integer , the fractional part is truncated. If the truncated value cannot be represented in the destination type, the behavior is TBD ( #180 ).

Conversion involving complex-to-complex follow the same behavior of floating-point-to-floating-point conversions for converting real and imaginary parts.

For complex-to-any-other-type and any-other-type-to-complex conversions, the source imaginary value is ignored or the destination imaginary value is zeroed, respectively. The conversion of the real part follows the floating-point conversions.

In principle, this operation could express dequantization (conversion from quantized tensors to regular tensors), quantization (conversion from regular tensors to quantized tensors) and requantization (conversion between quantized tensors), but at the moment we have dedicated operations for that - uniform_dequantize for the first use case and uniform_quantize for the second and the third use cases. In the future, these two ops may be merged into convert ( #1576 ).

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) shape(operand) = shape(result) .

উদাহরণ

// %operand: [-1, 0, 1]
%result = "stablehlo.convert"(%operand) : (tensor<3xi64>) -> tensor<3xcomplex<f64>>
// %result: [(-1.0, 0.0), (0.0, 0.0), (1.0, 0.0)]

আরও উদাহরণ

ঘূর্ণন

শব্দার্থবিদ্যা

Computes dot products between windows of lhs and slices of rhs and produces result . The following diagram shows how elements in result are computed from lhs and rhs using a concrete example.

More formally, consider the following reframing of the inputs in terms of lhs in order to be able to express windows of lhs :

• lhs_window_dimensions = lhs_shape(dim(lhs, input_batch_dimension), dim(rhs, kernel_spatial_dimensions), dim(lhs, input_feature_dimension)) .
• lhs_window_strides = lhs_shape(1, window_strides, 1) .
• lhs_padding = lhs_shape([0, 0], padding, [0, 0]) .
• lhs_base_dilations = lhs_shape(1, lhs_dilation, 1) .
• lhs_window_dilations = lhs_shape(1, rhs_dilation, 1) .

This reframing uses the following helper functions:

• lhs_shape(n, hw, c) = permute([n] + hw + [c], [input_batch_dimension] + input_spatial_dimensions + [input_feature_dimension]) .
• result_shape(n1, hw, c1) = permute([n1] + hw + [c1], [output_batch_dimension] + output_spatial_dimensions + [output_feature_dimension]) .
• permute([j0, j1, ..., jR-1], permutation) = [i0, i1, ..., iR-1] where j[d] = i[permutation[d]] .

If feature_group_count = 1 and batch_group_count = 1 , then for all output_spatial_index in index_space(dim(result, output_spatial_dimensions...)) , result[result_shape(:, output_spatial_index, :)] = dot_product where:

• padding_value = constant(0, element_type(lhs)) .
• padded_lhs = pad(lhs, padding_value, lhs_padding[:, 0], lhs_padding[:, 1], lhs_base_dilations - 1) .
• lhs_window_start = lhs_shape(0, output_spatial_index, 0) * lhs_window_strides .
• lhs_window = slice(padded_lhs, lhs_window_start, lhs_window_start + lhs_window_dimensions, lhs_window_dilations) .
• reversed_lhs_window = reverse(lhs_window, [input_spatial_dimensions[dim] for dim in range(size(window_reversal)) if window_reversal[dim] = true]) . This feature appears to be unused, so in the future we are planning to remove it ( #1181 ).
• dot_product = dot_general(reversed_lhs_window, rhs, lhs_batching_dimensions=[], lhs_contracting_dimensions=input_spatial_dimensions + [input_feature_dimension], rhs_batching_dimensions=[], rhs_contracting_dimensions=kernel_spatial_dimensions + [kernel_input_feature_dimension]) .

If feature_group_count > 1 :

• lhses = split(lhs, feature_group_count, input_feature_dimension) .
• rhses = split(rhs, feature_group_count, kernel_output_feature_dimension) .
• results... = convolution(lhses..., rhses..., ..., feature_group_count=1, ...) .
• result = concatenate(results, output_feature_dimension) .

If batch_group_count > 1 :

• lhses = split(lhs, batch_group_count, input_batch_dimension) .
• rhses = split(rhs, batch_group_count, kernel_output_feature_dimension) .
• results... = convolution(lhses..., rhses..., ..., batch_group_count=1, ...) .
• result = concatenate(results, output_feature_dimension) .

For quantized types, performs dequantize_op_quantize( lambda lhs, rhs: convolution(lhs, rhs, window_strides, padding, lhs_dilation, rhs_dilation, window_reversal, input_batch_dimension, input_feature_dimension, input_spatial_dimensions, kernel_input_feature_dimension, kernel_output_feature_dimension, kernel_spatial_dimensions, output_batch_dimension, output_feature_dimension, output_spatial_dimensions, feature_group_count, batch_group_count, precision_config), lhs, rhs, type(result)) .

For hybrid quantized types, performs hybrid_dequantize_then_op( lambda lhs, rhs: convolution(lhs, rhs, window_strides, padding, lhs_dilation, rhs_dilation, window_reversal, input_batch_dimension, input_feature_dimension, input_spatial_dimensions, kernel_input_feature_dimension, kernel_output_feature_dimension, kernel_spatial_dimensions, output_batch_dimension, output_feature_dimension, output_spatial_dimensions, feature_group_count, batch_group_count, precision_config), lhs, rhs) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) N = rank(lhs) = rank(rhs) .
• (C2) size(window_strides) = N - 2 .
• (C3) 0 < window_strides .
• (C4) shape(padding) = [N - 2, 2] .
• (C5) size(lhs_dilation) = N - 2 .
• (C6) 0 < lhs_dilation .
• (C7) size(rhs_dilation) = N - 2 .
• (C8) 0 < rhs_dilation .
• (C9) size(window_reversal) = N - 2 .
• (C10) dim(lhs, input_batch_dimension) % batch_group_count = 0 .
• (C11) dim(lhs, input_feature_dimension) % feature_group_count = 0 .
• (C12) size(input_spatial_dimensions) = N - 2 .
• (C13) Given input_dimensions = [input_batch_dimension] + input_spatial_dimensions + [input_feature_dimension] :
  • is_unique(input_dimensions) .
  • 0 <= input_dimensions < N .
• (C14) dim(rhs, kernel_input_feature_dimension) = dim(lhs, input_feature_dimension) / feature_group_count .
• (C15) dim(rhs, kernel_output_feature_dimension) % batch_group_count = 0 .
• (C16) dim(rhs, kernel_output_feature_dimension) % feature_group_count = 0 .
• (C17) size(kernel_spatial_dimensions) = N - 2 .
• (C18) Given kernel_dimensions = kernel_spatial_dimensions + [kernel_input_feature_dimension] + [kernel_output_feature_dimension] :
  • is_unique(kernel_dimensions) .
  • 0 <= kernel_dimensions < N .
• (C19) size(output_spatial_dimensions) = N - 2 .
• (C20) Given output_dimensions = [output_batch_dimension] + output_spatial_dimensions + [output_feature_dimension] :
  • is_unique(output_dimensions) .
  • 0 <= output_dimensions < N .
• (C21) 0 < feature_group_count .
• (C22) 0 < batch_group_count .
• (C23) feature_group_count = 1 or batch_group_count = 1 .
• (C24) size(precision_config) = 2 .
• (C25) dim(result, result_dim) is defined as:
  • dim(lhs, input_batch_dimension) / batch_group_count if result_dim = output_batch_dimension .
  • dim(rhs, kernel_output_feature_dimension) if result_dim = output_feature_dimension .
  • num_windows otherwise, where:
  • output_spatial_dimensions[spatial_dim] = result_dim .
  • lhs_dim = input_spatial_dimensions[spatial_dim] .
  • rhs_dim = kernel_spatial_dimensions[spatial_dim] .
  • dilated_input_shape[lhs_dim] = dim(lhs, lhs_dim) = 0 ? 0 : (dim(lhs, lhs_dim) - 1) * lhs_dilation[spatial_dim] + 1 .
  • padded_input_shape[lhs_dim] = padding[spatial_dim, 0] + dilated_input_shape[lhs_dim] + padding[spatial_dim, 1] .
  • dilated_window_shape[lhs_dim] = dim(rhs, rhs_dim) = 0 ? 0 : (dim(rhs, rhs_dim) - 1) * rhs_dilation[spatial_dim] + 1 .
  • is_empty_window[lhs_dim] = padded_input_shape[lhs_dim] = 0 || dilated_window_shape[lhs_dim] > padded_input_shape[lhs_dim] .
  • num_windows = is_empty_window[lhs_dim] ? 0 : floor((padded_input_shape[lhs_dim] - dilated_window_shape[lhs_dim]) / window_strides[spatial_dim]) + 1 .
• (C26) rank(result) = N .
• If the operation uses non-quantized tensors:
  • (C27) element_type(lhs) = element_type(rhs) = element_type(result) .
• If the operation uses quantized tensors:
  • (C28) is_quantized(lhs) = is_quantized(result) and is_quantized(rhs) .
  • (C29) If is_per_axis_quantized(rhs) , then quantization_dimension(rhs) = kernel_output_feature_dimension .
  • (C30) If is_per_axis_quantized(result) , then quantization_dimension(result) = output_feature_dimension .
  • If is_quantized(lhs) :
  • (C31) storage_type(lhs) = storage_type(rhs) .
  • (C32) expressed_type(lhs) = expressed_type(rhs) = expressed_type(result) .
  • (C33) If is_per_tensor_quantized(rhs) , then is_per_tensor_quantized(result) .
  • If !is_quantized(lhs) :
  • (C34) element_type(lhs) = expressed_type(rhs) = element_type(result) .

উদাহরণ

// %lhs: [[
//        [
//          [1], [2], [5], [6]
//        ],
//        [
//          [3], [4], [7], [8]
//        ],
//        [
//          [10], [11], [14], [15]
//        ],
//        [
//          [12], [13], [16], [17]
//        ]
//      ]]
//
// %rhs: [
//        [[[1]], [[1]], [[1]]],
//        [[[1]], [[1]], [[1]]],
//        [[[1]], [[1]], [[1]]]
//       ]
%result = "stablehlo.convolution"(%lhs, %rhs) {
  window_strides = array<i64: 4, 4>,
  padding = dense<0> : tensor<2x2xi64>,
  lhs_dilation = array<i64: 2, 2>,
  rhs_dilation = array<i64: 1, 1>,
  window_reversal = array<i1: false, false>,
  // In the StableHLO dialect, dimension numbers are encoded via:
  // `[<input dimensions>]x[<kernel dimensions>]->[output dimensions]`.
  // "b" is batch dimension, "f" is feature dimension,
  // "i" is input feature dimension, "o" is output feature dimension,
  // "0/1/etc" are spatial dimensions.
  dimension_numbers = #stablehlo.conv<[b, 0, 1, f]x[0, 1, i, o]->[b, 0, 1, f]>,
  batch_group_count = 1 : i64,
  feature_group_count = 1 : i64,
  precision_config = [#stablehlo<precision DEFAULT>, #stablehlo<precision DEFAULT>]
} : (tensor<1x4x4x1xi64>, tensor<3x3x1x1xi64>) -> tensor<1x2x2x1xi64>
// %result: [[
//            [[10], [26]],
//            [[46], [62]]
//          ]]

আরও উদাহরণ

কোসাইন

শব্দার্থবিদ্যা

Performs element-wise cosine operation on operand tensor and produces a result tensor. Depending on the element type, does the following:

• For floats: cos from IEEE-754.
• For complex numbers: complex cosine.
• For quantized types: dequantize_op_quantize(cosine, operand, type(result)) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) baseline_type(operand) = baseline_type(result) .

উদাহরণ

// %operand: [
//            [0.0, 1.57079632],       // [0, pi/2]
//            [3.14159265, 4.71238898] // [pi, 3pi/2]
//           ]
%result = "stablehlo.cosine"(%operand) : (tensor<2x2xf32>) -> tensor<2x2xf32>
// %result: [[1.0, 0.0], [-1.0, 0.0]]

আরও উদাহরণ

count_leading_zeros

শব্দার্থবিদ্যা

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

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) type(operand) = type(result) .

উদাহরণ

// %operand: [[0, 1], [128, -1]]
%result = "stablehlo.count_leading_zeros"(%operand) : (tensor<2x2xi64>) -> tensor<2x2xi64>
// %result: [[64, 63], [56, 0]]

আরও উদাহরণ

custom_call

শব্দার্থবিদ্যা

Encapsulates an implementation-defined operation call_target_name that takes inputs and called_computations and produces results . has_side_effect , backend_config and api_version may be used to provide additional implementation-defined metadata.

At the moment, this operation contains a fairly disorganized collection of metadata which reflects organic evolution of its counterpart operation in the XLA compiler. In the future, we are planning to unify this metadata ( #741 ).

ইনপুট

আউটপুট

(XLA GPU Support) Special custom_call targets

There are three special call_target_name related to buffer types: CreateBuffer creates an uninitialized buffer , Pin creates an initialized buffer and Unpin deallocates a buffer and returns the content of the buffer .

%uninitialized_buffer = "stablehlo.custom_call"() {
  call_target_name = "CreateBuffer",
  api_version = 4 : i32,
} : () -> memref<4xf64>

%initialized_buffer = "stablehlo.custom_call"(%init_value) {
  call_target_name = "Pin",
  api_version = 4 : i32,
} : (tensor<4xf64>) -> memref<4xf64>

%dealloc_buffer = "stablehlo.custom_call"(%initialized_buffer) {
  call_target_name = "Unpin",
  api_version = 4 : i32,
} : (memref<4xf64>) -> tensor<4xf64>

উপনাম

Some custom_call ops may require a part in the outputs and a part in the operands to share the same memory. This can be expressed via output_operand_aliases . An alias pair representation consists a list of output tuple indices representing the output part, and an operand_index along with a list of operand tuple indices representing the operand part. The list of output or operand tuple indices is empty if the corresponding type is not a tuple type, and can be arbitrarily long for an arbitrarily nested tuple type. This is similar to the XLA alias representation .

The output part and the input part in an alias pair must have the same type. For custom_call ops that aren't call to CreateBuffer , Pin and Unpin , a buffer operand can appear in at most one pair of alias, and a buffer output must appear in one pair of alias.

উদাহরণ

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

%updated_buffer = "stablehlo.custom_call"(%buffer) {
  call_target_name = "Update",
  api_version = 4 : i32,
  output_operand_aliases = [
    #stablehlo.output_operand_alias<output_tuple_indices = [],
      operand_index = 0,
      operand_tuple_indices = []>]
} : (memref<4xf64>) -> memref<4xf64>

ভাগ করা

শব্দার্থবিদ্যা

Performs element-wise division of dividend lhs and divisor rhs tensors and produces a result tensor. Depending on the element type, does the following:

• For integers: integer division which produces the algebraic quotient with any fractional part discarded.
• For floats: division from IEEE-754.
• For complex numbers: complex division.
• For quantized types:
  • dequantize_op_quantize(divide, lhs, rhs, type(result)) .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) baseline_type(lhs) = baseline_type(rhs) = baseline_type(result) .

উদাহরণ

// %lhs: [17.1, -17.1, 17.1, -17.1]
// %rhs: [3.0, 3.0, -3.0, -3.0]
%result = "stablehlo.divide"(%lhs, %rhs) : (tensor<4xf32>, tensor<4xf32>) -> tensor<4xf32>
// %result: [5.66666651, -5.66666651, -5.66666651, 5.66666651]

আরও উদাহরণ

dot_general

শব্দার্থবিদ্যা

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

More formally, result[result_index] = dot_product , where:

• lhs_result_dimensions = [d for d in axes(lhs) and d not in lhs_batching_dimensions and d not in lhs_contracting_dimensions] .
• rhs_result_dimensions = [d for d in axes(rhs) and d not in rhs_batching_dimensions and d not in rhs_contracting_dimensions] .
• result_batching_index + result_lhs_index + result_rhs_index = result_index where size(result_batching_index) = size(lhs_batching_dimensions) , size(result_lhs_index) = size(lhs_result_dimensions) and size(result_rhs_index) = size(rhs_result_dimensions) .
• transposed_lhs = transpose(lhs, lhs_batching_dimensions + lhs_result_dimensions + lhs_contracting_dimensions) .
• transposed_lhs_slice = slice(transposed_lhs, result_batching_index + result_lhs_index + [:, ..., :]) .
• reshaped_lhs_slice = reshape(transposed_lhs_slice, dims(lhs, lhs_contracting_dimensions)) .
• transposed_rhs = transpose(rhs, rhs_batching_dimensions + rhs_result_dimensions + rhs_contracting_dimensions) .
• transposed_rhs_slice = slice(transposed_rhs, result_batching_index + result_rhs_index + [:, ..., :]) .
• reshaped_rhs_slice = reshape(transposed_rhs_slice, dims(rhs, rhs_contracting_dimensions)) .
• dot_product = reduce( inputs=[multiply(reshaped_lhs_slice, reshaped_rhs_slice)], init_values=[constant(0, element_type(result))], dimensions=range(size(lhs_contracting_dimensions)), body=lambda x, y: add(x, y)) .

For quantized types, performs dequantize_op_quantize( lambda lhs, rhs: dot_general(lhs, rhs, lhs_batching_dimensions, rhs_batching_dimensions, lhs_contracting_dimensions, rhs_contracting_dimensions, precision_config), lhs, rhs, type(result)) .

For hybrid quantized types, performs hybrid_dequantize_then_op( lambda lhs, rhs: dot_general(lhs, rhs, lhs_batching_dimensions, rhs_batching_dimensions, lhs_contracting_dimensions, rhs_contracting_dimensions, precision_config), lhs, rhs) .

precision_config controls the tradeoff between speed and accuracy for computations on accelerator backends. This can be one of the following (at the moment, the semantics of these enum values is underspecified, but we are planning to address this in #755 ):

• DEFAULT : Fastest calculation, but least accurate approximation to the original number.
• HIGH : Slower calculation, but more accurate approximation to the original number.
• HIGHEST : Slowest calculation, but most accurate approximation to the original number.

A DotAlgorithm defines the main properties of the algorithm used to implement the dot operation, which also defines the precision. If the algorithm attribute fields are set, then the precision_config must be DEFAULT . DotAlgorithms do not have a default value, as the default parameters are implementation defined. As such, all dot algorithm fields may be set to None to specify an empty dot algorithm, which will instead use the precision_config value.

DotAlgorithm fields include:

• lhs_precision_type and rhs_precision_type , the precisions that the LHS and RHS of the operation are rounded to. Precision types are independent from the storage types of the inputs and the output.
• accumulation_type the precision used for accumulation.
• lhs_component_count , rhs_component_count , and num_primitive_operations apply when we are doing an algorithm which decomposes the LHS and/or RHS into multiple components and does multiple "primitive" dot operations on those values - usually to emulate a higher precision (eg Leveraging the bfloat16 Artificial Intelligence Datatype For Higher-Precision Computations : bf16_6x tf32_3x, etc). For algorithms with no decomposition, these values should be set to 1 .
• allow_imprecise_accumulation to specify if accumulation in lower precision is permitted for some steps (eg CUBLASLT_MATMUL_DESC_FAST_ACCUM ).

Example DotAlgorithm attributes:

// Inputs are casted to tf32, and then accumulated in f32:
{lhs_precision_type = tf32,
 rhs_precision_type = tf32,
 accumulation_type = f32,
 lhs_component_count = 1,
 rhs_component_count = 1,
 num_primitive_operations = 1,
 allow_imprecise_accumulation = false}


// bf16_6x: each input is decomposed to 3 bf16 components, then 6 dot operations are done on those components, and the result is accumulated in f32.
{lhs_precision_type = bf16,
 rhs_precision_type = bf16,
 accumulation_type = f32,
 lhs_component_count = 3,
 rhs_component_count = 3,
 num_primitive_operations = 6,
 allow_imprecise_accumulation = false}


// Inputs are (casted to) f8e5m2, and we accumulate in f32, but for some steps we may accumulate in lower precision.
{lhs_precision_type = f8e5m2,
 rhs_precision_type = f8e5m2,
 accumulation_type = f32,
 lhs_component_count = 1,
 rhs_component_count = 1,
 num_primitive_operations = 1,
 allow_imprecise_accumulation = true}

It is up to the implementations to decide which combinations are supported. In general, it is not guaranteed that each algorithm is supported on each accelerator type by the consumer of the StableHLO. If a given algorithm is not supported, an error should be raised as opposed to falling back to an alternative. StableHLO verification will provide best effort verification, preventing algorithms that are not known to be supported on any hardware.

See xla_data.proto > Algorithm for some supported algorithm values. Ticket #2483 captures the plan to create a centralized doc on supported algorithms by backend.

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) size(lhs_batching_dimensions) = size(rhs_batching_dimensions) .
• (C2) size(lhs_contracting_dimensions) = size(rhs_contracting_dimensions) .
• (C3) is_unique(lhs_batching_dimensions + lhs_contracting_dimensions) .
• (C4) is_unique(rhs_batching_dimensions + rhs_contracting_dimensions) .
• (C5) 0 <= lhs_batching_dimensions < rank(lhs) .
• (C6) 0 <= lhs_contracting_dimensions < rank(lhs) .
• (C7) 0 <= rhs_batching_dimensions < rank(rhs) .
• (C8) 0 <= rhs_contracting_dimensions < rank(rhs) .
• (C9) dim(lhs, lhs_batching_dimensions...) = dim(rhs, rhs_batching_dimensions...) .
• (C10) dim(lhs, lhs_contracting_dimensions...) = dim(rhs, rhs_contracting_dimensions...) .
• (C11) size(precision_config) = 2 .
• (C12) shape(result) = dim(lhs, lhs_batching_dimensions) + dim(lhs, lhs_result_dimensions) + dim(rhs, rhs_result_dimensions) .
• If the operation uses non-quantized tensors:
  • (C13) element_type(lhs) = element_type(rhs) .
• If the operation uses quantized tensors:
  • (C14) is_quantized(lhs) = is_quantized(result) and is_quantized(rhs) .
  • (C15) zero_points(rhs) = 0 .
  • (C16) If is_per_axis_quantized(rhs) , then quantization_dimension(rhs) not in rhs_contracting_dimensions .
  • If is_quantized(lhs) :
  • (C17) storage_type(lhs) = storage_type(rhs) .
  • (C18) expressed_type(lhs) = expressed_type(rhs) = expressed_type(result) .
  • (C19) If is_per_tensor_quantized(rhs) , then is_per_tensor_quantized(result) .
  • If !is_quantized(lhs) :
  • (C20) element_type(lhs) = expressed_type(rhs) = element_type(result) .
• If !is_empty_algorithm(lhs_precision_type, rhs_precision_type, accumulation_type, lhs_component_count, rhs_component_count, num_primitive_operations allow_imprecise_accumulation) :
  • (C21) precision_config... = DEFAULT .
  • (C22) 0 < lhs_component_count .
  • (C23) 0 < rhs_component_count .
  • (C24) 0 < num_primitive_operations .

উদাহরণ

// %lhs: [
//        [[1, 2],
//         [3, 4]],
//        [[5, 6],
//         [7, 8]]
//       ]
// %rhs: [
//        [[1, 0],
//         [0, 1]],
//        [[1, 0],
//         [0, 1]]
//       ]
%result = "stablehlo.dot_general"(%lhs, %rhs) {
  dot_dimension_numbers = #stablehlo.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>],
  algorithm = #stablehlo.dot_algorithm<
    lhs_precision_type = tf32,
    rhs_precision_type = tf32,
    accumulation_type = f32,
    lhs_component_count = 1,
    rhs_component_count = 1,
    num_primitive_operations = 1,
    allow_imprecise_accumulation = false
  >
} : (tensor<2x2x2xi64>, tensor<2x2x2xi64>) -> tensor<2x2x2xi64>
// %result: [
//           [[1, 2],
//            [3, 4]],
//           [[5, 6],
//            [7, 8]]
//          ]

আরও উদাহরণ

dynamic_broadcast_in_dim

শব্দার্থবিদ্যা

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

The operation also accepts optional attributes known_expanding_dimensions , known_nonexpanding_dimensions to express static knowledge about the expanding behavior of dimensions. If not specified, all dimensions are assumed to be possibly expanding.

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) element_type(result) is given by:
  • element_type(operand) , if !is_per_axis_quantized(operand) .
  • element_type(operand) except that quantization_dimension(operand) , scales(operand) , and zero_points(operand) may differ from quantization_dimension(result) , scales(result) , and zero_points(result) resp., otherwise.
• (C2) size(broadcast_dimensions) = rank(operand) .
• (C3) 0 <= broadcast_dimensions < rank(result) .
• (C4) is_unique(broadcast_dimensions) .
• (C5) For all d in axes(operand) :
  • dim(operand, d) = 1 or
  • dim(operand, d) = dim(result, broadcast_dimensions[d]) .
• (C6) If is_per_axis_quantized(result) :
  • quantization_dimension(result) = broadcast_dimensions[quantization_dimension(operand)] .
  • If dim(operand, quantization_dimension(operand)) = 1 , then scales(result)[i] = scales(operand)[0] and zero_points(result)[i] = zero_points(operand)[0] for i in range(dim(result, quantization_dimension(result))) .
• (C7) size(output_dimensions) = rank(result) .
• (C8) is_unique(known_expanding_dimensions + known_nonexpanding_dimensions) .
• (C9) 0 <= known_expanding_dimensions < rank(operand) .
• (C10) 0 <= known_nonexpanding_dimensions < rank(operand) .

উদাহরণ

// %operand: [
//            [1, 2, 3]
//           ]
%operand = stablehlo.constant dense<[[1, 2, 3]]> : tensor<1x3xi64>
%output_dimensions = stablehlo.constant dense<[2, 3, 2]> : tensor<3xi64>
%result = "stablehlo.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>
// %result: [
//            [
//             [1, 1],
//             [2, 2],
//             [3, 3]
//            ],
//            [
//             [1, 1],
//             [2, 2],
//             [3, 3]
//            ]
//          ]

আরও উদাহরণ

dynamic_conv

শব্দার্থবিদ্যা

This operation is functionally identical to convolution op, but the padding is specified dynamically via padding .

ইনপুট