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

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

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

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

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

প্রোগ্রাম

Program ::= {Func}

StableHLO প্রোগ্রামগুলি একটি নির্বিচারে StableHLO ফাংশন নিয়ে গঠিত। নিচে @main ফাংশন সহ একটি উদাহরণ প্রোগ্রাম রয়েছে যাতে 3টি ইনপুট ( %image , %weights এবং %bias ) এবং 1টি আউটপুট রয়েছে। ফাংশনের শরীরে 6টি অপ্স আছে।

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 শনাক্তকারী অনেক প্রোগ্রামিং ভাষায় শনাক্তকারীর মতো, দুটি বিশেষত্ব সহ: 1) সমস্ত শনাক্তকারীর সিগিল থাকে যা বিভিন্ন ধরণের শনাক্তকারীকে আলাদা করে, 2) স্ট্যাবলএইচএলও প্রোগ্রামের প্রজন্মকে সহজ করার জন্য মান শনাক্তকারী সম্পূর্ণরূপে সংখ্যাসূচক হতে পারে।

প্রকারভেদ

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

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

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

টেনসরের ধরনগুলি টেনসরকে প্রতিনিধিত্ব করে, যেমন বহুমাত্রিক অ্যারে। তাদের একটি আকৃতি এবং একটি উপাদানের ধরন রয়েছে, যেখানে একটি আকৃতি 0 থেকে R-1 পর্যন্ত সংখ্যাযুক্ত সংশ্লিষ্ট মাত্রাগুলির (যাকে অক্ষও বলা হয়) এর আরোহী ক্রমে নন-নেতিবাচক বা অজানা মাত্রার আকারগুলিকে প্রতিনিধিত্ব করে। R মাত্রার সংখ্যাকে র‌্যাঙ্ক বলা হয়। উদাহরণস্বরূপ, 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 (অন্তর্ভুক্ত) পরিসরে একটি স্টোরেজ প্রকারের পূর্ণসংখ্যার মানগুলিকে উপস্থাপন করে যা একটি প্রকাশিত ধরণের ফ্লোটিং-পয়েন্ট মানগুলির সাথে মিলে যায়। একটি প্রদত্ত পূর্ণসংখ্যার মান i জন্য, সংশ্লিষ্ট ফ্লোটিং-পয়েন্ট মান f f = (i - zero_point) * scale হিসাবে গণনা করা যেতে পারে, যেখানে scale এবং zero_point কে কোয়ান্টাইজেশন প্যারামিটার বলা হয়। 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 ) প্রতিনিধিত্ব করে অন্বেষণ করার পরিকল্পনা করছি।

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

কোয়ান্টাইজেশন টেনসরে, কোয়ান্টাইজেশন প্রতি-টেনসর হতে পারে, যার অর্থ, সমগ্র টেনসরের জন্য একটি scale এবং zero_point থাকতে পারে বা প্রতি-অক্ষ হতে পারে, যার অর্থ, একাধিক scales এবং zero_points থাকতে পারে, একটি নির্দিষ্ট মাত্রা quantization_dimension প্রতি স্লাইসে এক জোড়া। আরও আনুষ্ঠানিকভাবে, প্রতি-অক্ষ পরিমাপ সহ একটি টেনসর 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}]

Tuple প্রকারগুলি tuples, অর্থাৎ ভিন্নধর্মী তালিকাগুলিকে প্রতিনিধিত্ব করে। Tuples হল একটি উত্তরাধিকার বৈশিষ্ট্য যা শুধুমাত্র 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 প্রোগ্রামগুলি এই ধরণের মানগুলিকে সরাসরি উপস্থাপন করতে পারে না (ফলে, টাইপ tensor<T> > এর 0-মাত্রিক টেনসর মানগুলির সাথে T টাইপের স্কেলার মানগুলিকে উপস্থাপন করা বাহাদুরিপূর্ণ)।

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

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

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

StringType ::= 'string'

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

অপারেশন

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

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

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

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

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

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

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

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

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

ইনপুট বৈশিষ্ট্যগুলির একটি নাম এবং একটি মান রয়েছে যা সমর্থিত ধ্রুবকগুলির মধ্যে একটি৷ তারা প্রোগ্রাম উপাদানগুলির জন্য স্ট্যাটিক মেটাডেটা নির্দিষ্ট করার প্রাথমিক উপায়। উদাহরণ স্বরূপ, concatenate op বৈশিষ্ট্যের dimension ব্যবহার করে তার ইনপুট মানগুলি যে মাত্রার সাথে সংযুক্ত করা হয়েছে তা নির্দিষ্ট করতে। একইভাবে, slice অপটি ইনপুট মান স্লাইস করতে ব্যবহৃত সীমানা নির্দিষ্ট করতে 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}] ')'

অপ স্বাক্ষরে সমস্ত ইনপুট মান ( -> এর বাম দিকের প্রকারের তালিকা) এবং সমস্ত আউটপুট মানগুলির প্রকার ( -> এর ডানদিকের প্রকারের তালিকা) থাকে। কঠোরভাবে বলতে গেলে, ইনপুট প্রকারগুলি অপ্রয়োজনীয়, এবং আউটপুট প্রকারগুলি প্রায় সবসময়ই অপ্রয়োজনীয় (কারণ বেশিরভাগ 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 মান উপস্থাপন করে। সাধারণত, টাইপটি ধ্রুবক সিনট্যাক্সের অংশ, এটি দ্ব্যর্থহীন হলে (যেমন একটি বুলিয়ান ধ্রুবকের দ্ব্যর্থহীনভাবে 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 থাকে।

অপ্স

abs

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

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

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

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) shape(result) = shape(operand) ।
• (C2) baseline_element_type(result) এইভাবে সংজ্ঞায়িত করা হয়েছে:
  • 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 ।
• জটিল সংখ্যার জন্য: জটিল যোগ।
• quantized প্রকারের জন্য: 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 এ বিভক্ত করে যা নিম্নরূপ সংজ্ঞায়িত করা হয়েছে:

• 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 = false ।
• flattened_ids(replica_groups) যদি channel_id > 0 and use_global_device_ids = true ।

পরে, প্রতিটি 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) সংজ্ঞায়িত করা হয়েছে এভাবে:
  • num_replicas যদি cross_replica ব্যবহার করা হয়।
  • num_replicas যদি cross_replica_and_partition ব্যবহার করা হয়।
  • num_processes যদি flattened_ids ব্যবহার করা হয়।
• (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]]

আরো উদাহরণ

all_reduce

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

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

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

• 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 = false ।
• flattened_ids(replica_groups) যদি channel_id > 0 and use_global_device_ids = true ।

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

• results...@process[result_index] = exec(schedule) কিছু বাইনারি ট্রি schedule জন্য exec(সূচি) যেখানে:
  • 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) এইভাবে সংজ্ঞায়িত করা হয়েছে:
  • num_replicas যদি cross_replica ব্যবহার করা হয়।
  • num_replicas যদি cross_replica_and_partition ব্যবহার করা হয়।
  • num_processes যদি flattened_ids ব্যবহার করা হয়।
• (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 এ বিভক্ত করে যা নিম্নরূপ সংজ্ঞায়িত করা হয়েছে:

• cross_replica(replica_groups) যদি channel_id <= 0 হয়।
• cross_partition(replica_groups) যদি channel_id > 0 হয়।

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

• split_parts...@sender = split(operands...@sender, split_count, split_dimension) process_group সকল sender জন্য।
• 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) এইভাবে সংজ্ঞায়িত করা হয়েছে:
  • num_replicas যদি cross_replica ব্যবহার করা হয়।
  • num_partitions যদি cross_partition ব্যবহার করা হয়।
• (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 টেনসর তৈরি করে। উপাদান প্রকারের উপর নির্ভর করে, নিম্নলিখিতগুলি করে:

• বুলিয়ানদের জন্য: যৌক্তিক এবং।
• পূর্ণসংখ্যার জন্য: bitwise 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

quantized প্রকারের জন্য, 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)

quantized প্রকারের জন্য, 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 ডাইমেনশন ব্যতীত সমস্ত মাত্রা জুড়ে কম্পিউট মানে এবং ভ্যারিয়েন্স এবং output , batch_mean এবং batch_var টেনসর উত্পাদনকারী operand টেনসরকে স্বাভাবিক করে। আরও আনুষ্ঠানিকভাবে, এই ক্রিয়াকলাপটি নিম্নরূপ পাইথন সিনট্যাক্স ব্যবহার করে বিদ্যমান 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

quantized ধরনের জন্য, 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]

bitcast_convert

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

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

আরো আনুষ্ঠানিকভাবে, দেওয়া হল 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 একটি প্রদত্ত মানের ইন-মেমরি উপস্থাপনা প্রদান করে, এবং এর আচরণটি বাস্তবায়ন-সংজ্ঞায়িত কারণ টেনসরগুলির সঠিক উপস্থাপনাটি বাস্তবায়ন-সংজ্ঞায়িত, এবং উপাদান প্রকারের সঠিক উপস্থাপনাটি বাস্তবায়ন-সংজ্ঞায়িত।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (C1) দেওয়া E = is_quantized(operand) ? storage_type(operand) : element_type(operand) , E' = is_quantized(result) ? storage_type(result) : element_type(result) , এবং R = rank(operand) :
  • যদি num_bits(E') = num_bits(E) , shape(result) = shape(operand) ।
  • যদি num_bits(E') < num_bits(E) :
  • rank(result) = R + 1 ।
  • dim(result, i) = dim(operand, i) সব 0 <= i < R জন্য।
  • dim(result, R) * num_bits(E') = num_bits(E) ।
  • যদি num_bits(E') > num_bits(E) :
  • rank(result) = R - 1 ।
  • dim(result, i) = dim(operand, i) সব 0 <= i < R জন্য।
  • dim(operand, R - 1) * num_bits(E) = num_bits(E') ।
• (C2) যদি is_complex(operand) or is_complex(result) হয়, তাহলে 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

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

operand টেনসরে ডেটা নকল করে একটি ইনপুট টেনসরের মাত্রা এবং/অথবা র‌্যাঙ্ক প্রসারিত করে এবং result টেনসর তৈরি করে। আরও আনুষ্ঠানিকভাবে, result[result_index] = operand[operand_index] যেখানে সমস্ত d axes(operand) :

• operand_index[d] = 0 যদি dim(operand, d) = 1 ।
• operand_index[d] = result_index[broadcast_dimensions[d]] অন্যথায়।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) element_type(result) দ্বারা দেওয়া হয়েছে:
  • element_type(operand) , যদি !is_per_axis_quantized(operand) ।
  • element_type(operand) ব্যতীত quantization_dimension(operand) , scales(operand) , এবং zero_points(operand) quantization_dimension(result) , scales(result) , এবং zero_points(result) রেসপন্স থেকে পৃথক হতে পারে, অন্যথায়।
• (সি 2) size(broadcast_dimensions) = rank(operand) ।
• (সি 3) 0 <= broadcast_dimensions < rank(result) ।
• (সি 4) is_unique(broadcast_dimensions) ।
• (সি 5) সমস্ত d axes(operand) :
  • dim(operand, d) = 1 বা
  • dim(operand, d) = dim(result, broadcast_dimensions[d]) ।
• (সি 6) যদি is_per_axis_quantized(result) :
  • quantization_dimension(result) = broadcast_dimensions[quantization_dimension(operand)] ।
  • যদি dim(operand, quantization_dimension(operand)) = 1 , তবে 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]
//            ]
//          ]

আরো উদাহরণ

মামলা

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

index মানের উপর নির্ভর করে branches থেকে ঠিক একটি ফাংশন সম্পাদন করে আউটপুট উত্পাদন করে। আরও আনুষ্ঠানিকভাবে, result = selected_branch() যেখানে:

• selected_branch = branches[index] যদি 0 <= index < size(branches) ।
• selected_branch = branches[-1] অন্যথায়।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) 0 < size(branches) ।
• (সি 2) input_types(branches...) = [] ।
• (সি 3) same(output_types(branches...)) ।
• (সি 4) 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]

আরো উদাহরণ

সিবিআরটি

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

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

• ভাসমানগুলির জন্য: আইইইই -754 থেকে rootn(x, 3) ।
• জটিল সংখ্যার জন্য: জটিল কিউবিক রুট।
• কোয়ান্টাইজড প্রকারের জন্য: dequantize_op_quantize(cbrt, operand, type(result))

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) 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]

আরো উদাহরণ

ছাদ

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

operand টেনসারের উপাদান-ভিত্তিক সিল সম্পাদন করে এবং একটি result টেনসর তৈরি করে। আইইইইই -754 স্পেসিফিকেশন থেকে roundToIntegralTowardPositive অপারেশন প্রয়োগ করে। কোয়ান্টাইজড প্রকারের জন্য, dequantize_op_quantize(ceil, operand, type(result)) সম্পাদন করে।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) 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]

আরো উদাহরণ

চোলেস্কি

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

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

আরও আনুষ্ঠানিকভাবে, i index_space(result) জন্য, result[i0, ..., iR-3, :, :] a[i0, ..., iR-3, :, :] , এর একটি কোলেস্কি পচন নিম্ন-ত্রিভুজাকার উভয় আকারে (যদি lower true হয়) বা উপরের-ত্রিভুজাকার (যদি lower false হয়) ম্যাট্রিক্স। বিপরীত ত্রিভুজের আউটপুট মানগুলি, অর্থাত্ উচ্চতর ত্রিভুজ বা কঠোর নিম্ন ত্রিভুজ অনুসারে, বাস্তবায়ন-সংজ্ঞায়িত।

যদি সেখানে উপস্থিত থাকে i ইনপুট ম্যাট্রিক্স কোনও হার্মিটিয়ান পজিটিভ-ডিফিনেট ম্যাট্রিক্স নয়, তবে আচরণটি অপরিজ্ঞাত।

কোয়ান্টাইজড প্রকারের জন্য, dequantize_op_quantize(lambda operand: cholesky(operand, lower), a, type(result)) সম্পাদন করে।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) baseline_type(a) = baseline_type(result) ।
• (সি 2) 2 <= rank(a) ।
• (সি 3) 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]
//          ]

বাতা

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

ন্যূনতম এবং সর্বোচ্চ মানের মধ্যে operand টেনসারের প্রতিটি উপাদানকে ক্ল্যাম্প করে এবং result টেনসর তৈরি করে। আরও আনুষ্ঠানিকভাবে, result[result_index] = minimum(maximum(operand[result_index], min_element), max_element) , যেখানে min_element = rank(min) = 0 ? min[] : min[result_index] , max_element = rank(max) = 0 ? max[] : max[result_index] । কোয়ান্টাইজড প্রকারের জন্য, dequantize_op_quantize(clamp, min, operand, max, type(result)) সম্পাদন করে।

জটিল সংখ্যার উপর অর্ডার দেওয়ার ক্ষেত্রে অবাক করা শব্দার্থবিজ্ঞানের সাথে জড়িত, তাই ভবিষ্যতে আমরা এই অপারেশনের জন্য জটিল সংখ্যার জন্য সমর্থন অপসারণের পরিকল্পনা করছি ( #560 )।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) rank(min) = 0 or shape(min) = shape(operand) ।
• (সি 2) rank(max) = 0 or shape(max) = shape(operand) ।
• baseline_element_type(min) = baseline_element_type(operand) = baseline_element_type(max)
• (সি 4) 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]

আরো উদাহরণ

সমষ্টিগত_ব্রোডকাস্ট

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

স্থিতিশীলতা প্রক্রিয়া গ্রিডে প্রতিটি প্রক্রিয়া গোষ্ঠীর মধ্যে, উত্স প্রক্রিয়া থেকে operand টেনসারের মান লক্ষ্য প্রক্রিয়াগুলিতে প্রেরণ করুন এবং result টেনসর উত্পাদন করুন।

অপারেশনটি স্টেবলহ্লো প্রক্রিয়া গ্রিডকে process_groups গ্রুপগুলিতে বিভক্ত করে যা নিম্নলিখিত হিসাবে সংজ্ঞায়িত করা হয়েছে:

• cross_replica(replica_groups) যদি channel_id <= 0 ।
• cross_partition(replica_groups) যদি channel_id > 0 ।

এরপরে, result@process দেওয়া হয়:

• operand@process_groups[i, 0] যদি সেখানে উপস্থিত থাকে i প্রক্রিয়াটি process_groups[i] ।
• broadcast_in_dim(constant(is_quantized(result) ? quantize(0, element_type(result)) : 0, element_type(result)), [], type(result)) অন্যথায়।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) is_unique(replica_groups) ।
• (সি 2) 0 <= replica_groups < N যেখানে N হিসাবে সংজ্ঞায়িত করা হয়েছে:
  • num_replicas যদি cross_replica ব্যবহার করা হয়।
  • num_partitions যদি cross_partition ব্যবহার করা হয়।
• (সি 3) 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]]

সমষ্টিগত_প্রেমুট

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

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

অপারেশনটি স্টেবলহ্লো প্রক্রিয়া গ্রিডকে process_groups গ্রুপগুলিতে বিভক্ত করে যা নিম্নলিখিত হিসাবে সংজ্ঞায়িত করা হয়েছে:

• cross_replica(source_target_pairs) যদি channel_id <= 0 ।
• cross_partition(source_target_pairs) যদি channel_id > 0 ।

এরপরে, result@process দেওয়া হয়:

• operand@process_groups[i, 0] , যদি সেখানে উপস্থিত থাকে যে i যেমন process_groups[i, 1] = process ।
• broadcast_in_dim(constant(is_quantized(result) ? quantize(0, element_type(result)) : 0, element_type(result)), [], type(result)) অন্যথায়।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) dim(source_target_pairs, 1) = 2 ।
• (সি 2) is_unique(source_target_pairs[:, 0]) ।
• (সি 3) is_unique(source_target_pairs[:, 1]) ।
• (সি 4) 0 <= source_target_pairs < N , যেখানে N হিসাবে সংজ্ঞায়িত করা হয়েছে:
  • num_replicas যদি cross_replica ব্যবহার করা হয়।
  • num_partitions যদি cross_partition ব্যবহার করা হয়।
• (সি 5) 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 টেনসর তৈরি করে।

comparison_direction এবং compare_type মানগুলি নিম্নলিখিত শব্দার্থবিজ্ঞান রয়েছে:

বুলিয়ান এবং পূর্ণসংখ্যার উপাদানগুলির জন্য:

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

compare_type = FLOAT সহ ভাসমান-পয়েন্ট উপাদান প্রকারের জন্য, ওপি নিম্নলিখিত আইইইই -754 অপারেশনগুলি প্রয়োগ করে:

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

compare_type = TOTALORDER সহ ভাসমান-পয়েন্ট উপাদান প্রকারের জন্য, ওপি আইইইই -754 থেকে totalOrder এবং compareQuietEqual ক্রিয়াকলাপের সংমিশ্রণ ব্যবহার করে।

জটিল উপাদানগুলির জন্য, (real, imag) জোড়গুলির লিক্সোগ্রাফিক তুলনা প্রদত্ত comparison_direction এবং compare_type ব্যবহার করে সঞ্চালিত হয়। জটিল সংখ্যার উপর একটি ক্রম চাপানোতে আশ্চর্যজনক শব্দার্থবিজ্ঞানের সাথে জড়িত, সুতরাং ভবিষ্যতে আমরা comparison_direction GE , GT , LE বা LT ( #560 ) হলে জটিল সংখ্যার জন্য সমর্থন অপসারণের পরিকল্পনা করছি।

কোয়ান্টাইজড ধরণের জন্য। dequantize_compare(lhs, rhs, comparison_direction) ।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) baseline_element_type(lhs) = baseline_element_type(rhs) ।
• (সি 2) shape(lhs) = shape(rhs) = shape(result) ।
• (সি 3) compare_type হিসাবে সংজ্ঞায়িত করা হয়েছে:
  • SIGNED যদি is_signed_integer(element_type(lhs)) ।
  • UNSIGNED যদি is_unsigned_integer(element_type(lhs)) or is_boolean(element_type(lhs)) ।
  • FLOAT বা TOTALORDER যদি is_float(element_type(lhs)) ।
  • FLOAT যদি 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 টেনসর তৈরি করে।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) type(lhs) = type(rhs) ।
• (সি 2) shape(result) = shape(lhs) ।
• (সি 3) element_type(result) টাইপ complex<E> যেখানে 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)]

আরো উদাহরণ

যৌগিক

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

inputs এবং composite_attributes গ্রহণ এবং results উত্পাদন করে এমন অন্যান্য স্থিতিশীল অপারেশনগুলির তৈরি (রচিত) একটি অপারেশনকে এনক্যাপসুলেট করে। ওপি -র শব্দার্থবিজ্ঞানগুলি decomposition বৈশিষ্ট্য দ্বারা প্রয়োগ করা হয়। composite ওপি প্রোগ্রামের শব্দার্থবিজ্ঞান পরিবর্তন না করে তার পচন দিয়ে প্রতিস্থাপন করা যেতে পারে। যেসব ক্ষেত্রে পচনকে অন্তর্ভুক্ত করা একই ওপি শব্দার্থবিজ্ঞান সরবরাহ করে না, custom_call ব্যবহার করা পছন্দ করে।

version ক্ষেত্রটি ( 0 এ ডিফল্ট) যখন কোনও সংমিশ্রণের শব্দার্থবিজ্ঞানের পরিবর্তন হয় তখন বোঝাতে ব্যবহৃত হয়।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) is_namespaced_op_name(name)
• (সি 2) is_defined_in_parent_scope(decomposition)
• (সি 3) types(inputs...) == input_types(decomposition)
• (সি 4) 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>

আরো উদাহরণ

সংযুক্ত করা

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

প্রদত্ত আর্গুমেন্ট হিসাবে একই ক্রমে dimension মাত্রা বরাবর inputs কনটেনটেটস এবং result টেনসর তৈরি করে। আরও আনুষ্ঠানিকভাবে, result[i0, ..., id, ..., iR-1] = inputs[k][i0, ..., kd, ..., iR-1] , যেখানে:

1. id = d0 + ... + dk-1 + kd ।
2. d dimension সমান, এবং d0 , ... d inputs মাত্রা মাপ।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) same(element_type(inputs...)) ।
• (সি 2) same(shape(inputs...)) dim(inputs..., dimension) ব্যতীত।
• (সি 3) 0 < size(inputs) ।
• (সি 4) 0 <= dimension < rank(inputs[0]) ।
• (সি 5) element_type(result) = element_type(inputs[0]) ।
• (সি 6) shape(result) = shape(inputs[0]) ব্যতীত:
  • 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]]

আরো উদাহরণ

ধ্রুবক

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

একটি ধ্রুবক value থেকে একটি output টেনসর উত্পাদন করে।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) 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]]

আরো উদাহরণ

রূপান্তর

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

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

বুলিয়ান থেকে যে-কোনও-সমর্থিত-টাইপ রূপান্তরগুলির জন্য, মান false শূন্যে রূপান্তরিত হয় এবং true মানটি একটিতে রূপান্তরিত হয়। যে কোনও সমর্থিত-টাইপ-টু-বুলিয়ান রূপান্তরগুলির জন্য, একটি শূন্য মানকে false রূপান্তরিত করা হয়, এবং অ-শূন্য মানগুলি true রূপান্তরিত হয়। জটিল ধরণের জন্য এটি কীভাবে কাজ করে তার জন্য নীচে দেখুন।

পূর্ণসংখ্যা-থেকে-বুদ্ধিমান , পূর্ণসংখ্যা-থেকে-ভাসমান-পয়েন্ট বা ভাসমান-পয়েন্ট-থেকে-ভাসমান-পয়েন্ট জড়িত রূপান্তরগুলির জন্য, যদি উত্সের মানটি গন্তব্য প্রকারের মধ্যে হুবহু উপস্থাপিত হতে পারে তবে ফলাফলের মানটি সঠিক উপস্থাপনা। অন্যথায়, আচরণটি টিবিডি ( #180 )।

ভাসমান-পয়েন্ট-টু-ইনজিগারে জড়িত রূপান্তরগুলির জন্য, ভগ্নাংশের অংশটি কাটা হয়। যদি কাটা মানটি গন্তব্য প্রকারে প্রতিনিধিত্ব করা যায় না তবে আচরণটি টিবিডি ( #180 )।

জটিল থেকে জটিল জড়িত রূপান্তর বাস্তব এবং কল্পিত অংশগুলিকে রূপান্তর করার জন্য ভাসমান-পয়েন্ট-থেকে-ভাসমান-পয়েন্ট রূপান্তরগুলির একই আচরণ অনুসরণ করে।

জটিল-থেকে-অন্য-অন্য ধরণের এবং যে কোনও ধরণের থেকে জটিল রূপান্তরগুলির জন্য, উত্স কাল্পনিক মানটিকে উপেক্ষা করা হয় বা গন্তব্য কাল্পনিক মান যথাক্রমে শূন্য হয়। আসল অংশটির রূপান্তর ভাসমান-পয়েন্ট রূপান্তর অনুসরণ করে।

নীতিগতভাবে, এই অপারেশনটি ডেকুয়ান্টিজেশন (কোয়ান্টাইজড টেনসর থেকে নিয়মিত টেনারগুলিতে রূপান্তর), কোয়ান্টাইজেশন (নিয়মিত টেনারস থেকে কোয়ান্টাইজড টেনসরগুলিতে রূপান্তর) এবং প্রয়োজনীয়করণ (কোয়ান্টাইজড টেনসারের মধ্যে রূপান্তর) প্রকাশ করতে পারে, তবে এই মুহুর্তে আমরা সেই জন্য উত্সর্গীকৃত অপারেশনগুলি - uniform_dequantize প্রথম ব্যবহারের কেস এবং দ্বিতীয় এবং তৃতীয় ব্যবহারের ক্ষেত্রে uniform_quantize । ভবিষ্যতে, এই দুটি ওপি convert ( #1576 ) এ একীভূত হতে পারে।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) 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)]

আরো উদাহরণ

আবর্তন

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

lhs উইন্ডো এবং rhs স্লাইসগুলির মধ্যে ডট পণ্য গণনা করে এবং result উত্পাদন করে। নিম্নলিখিত চিত্রটি দেখায় যে কীভাবে result উপাদানগুলি lhs এবং rhs থেকে একটি কংক্রিট উদাহরণ ব্যবহার করে গণনা করা হয়।

আরও আনুষ্ঠানিকভাবে, lhs উইন্ডোজ প্রকাশ করতে সক্ষম হওয়ার জন্য 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) ।

এই রিফ্রেমিংটি নিম্নলিখিত সহায়ক ফাংশনগুলি ব্যবহার করে:

• 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] যেখানে j[d] = i[permutation[d]] ।

যদি feature_group_count = 1 এবং batch_group_count = 1 হয়, তবে সূচক_স্পেসে সমস্ত output_spatial_index জন্য index_space(dim(result, output_spatial_dimensions...)) , result[result_shape(:, output_spatial_index, :)] = dot_product যেখানে:

• 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]) । এই বৈশিষ্ট্যটি অব্যবহৃত বলে মনে হচ্ছে, সুতরাং ভবিষ্যতে আমরা এটি অপসারণের পরিকল্পনা করছি ( #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]) ।

যদি 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)

যদি 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)

কোয়ান্টাইজড প্রকারের জন্য, 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))

হাইব্রিড কোয়ান্টাইজড প্রকারের জন্য, 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) সম্পাদন করে 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)

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) N = rank(lhs) = rank(rhs) ।
• (সি 2) size(window_strides) = N - 2 ।
• (সি 3) 0 < window_strides ।
• (সি 4) shape(padding) = [N - 2, 2] ।
• (সি 5) size(lhs_dilation) = N - 2 ।
• (সি 6) 0 < lhs_dilation ।
• (সি 7) size(rhs_dilation) = N - 2 ।
• (সি 8) 0 < rhs_dilation ।
• (সি 9) size(window_reversal) = N - 2 ।
• (সি 10) dim(lhs, input_batch_dimension) % batch_group_count = 0 ।
• (সি 11) dim(lhs, input_feature_dimension) % feature_group_count = 0 ।
• (সি 12) size(input_spatial_dimensions) = N - 2 ।
• 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 ।
• (সি 15) dim(rhs, kernel_output_feature_dimension) % batch_group_count = 0 ।
• (সি 16) dim(rhs, kernel_output_feature_dimension) % feature_group_count = 0 ।
• (সি 17) size(kernel_spatial_dimensions) = N - 2 ।
• (C18) প্রদত্ত kernel_dimensions = kernel_spatial_dimensions + [kernel_input_feature_dimension] + [kernel_output_feature_dimension] :
  • is_unique(kernel_dimensions) ।
  • 0 <= kernel_dimensions < N ।
• (সি 19) size(output_spatial_dimensions) = N - 2 ।
• (সি 20) প্রদত্ত output_dimensions = [output_batch_dimension] + output_spatial_dimensions + [output_feature_dimension] :
  • is_unique(output_dimensions) ।
  • 0 <= output_dimensions < N ।
• (সি 21) 0 < feature_group_count ।
• (সি 22) 0 < batch_group_count ।
• (সি 23) feature_group_count = 1 or batch_group_count = 1 ।
• (সি 24) size(precision_config) = 2 ।
• (সি 25) dim(result, result_dim) হিসাবে সংজ্ঞায়িত করা হয়েছে:
  • dim(lhs, input_batch_dimension) / batch_group_count যদি result_dim = output_batch_dimension ।
  • dim(rhs, kernel_output_feature_dimension) যদি result_dim = output_feature_dimension ।
  • num_windows অন্যথায়, যেখানে:
  • 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 ।
• (সি 26) rank(result) = N ।
• যদি অপারেশনটি অ-কোয়ান্টাইজড টেনার ব্যবহার করে:
  • (সি 27) element_type(lhs) = element_type(rhs) = element_type(result) ।
• যদি অপারেশনটি কোয়ান্টাইজড টেনার ব্যবহার করে:
  • (সি 28) is_quantized(lhs) = is_quantized(result) and is_quantized(rhs) ।
  • (C29) যদি is_per_axis_quantized(rhs) , তবে quantization_dimension(rhs) = kernel_output_feature_dimension ।
  • (সি 30) যদি is_per_axis_quantized(result) হয়, তবে quantization_dimension(result) = output_feature_dimension ।
  • যদি is_quantized(lhs) :
  • (সি 31) storage_type(lhs) = storage_type(rhs) ।
  • (সি 32) expressed_type(lhs) = expressed_type(rhs) = expressed_type(result) ।
  • (C33) যদি is_per_tensor_quantized(rhs) , তবে is_per_tensor_quantized(result) ।
  • যদি !is_quantized(lhs) :
  • (সি 34) 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]]
//          ]]

আরো উদাহরণ

কোসাইন

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

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

• ভাসমানের জন্য: আইইইই -754 থেকে cos ।
• জটিল সংখ্যার জন্য: জটিল কোসাইন।
• কোয়ান্টাইজড প্রকারের জন্য: dequantize_op_quantize(cosine, operand, type(result)) ।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) 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

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

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

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) type(operand) = type(result) ।

উদাহরণ

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

আরো উদাহরণ

কাস্টম_ক্যাল

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

একটি বাস্তবায়ন-সংজ্ঞায়িত অপারেশন call_target_name এনক্যাপসুলেট করে যা inputs নেয় এবং called_computations গ্রহণ করে এবং results দেয়। has_side_effect , backend_config এবং api_version অতিরিক্ত বাস্তবায়ন-সংজ্ঞায়িত মেটাডেটা সরবরাহ করতে ব্যবহৃত হতে পারে।

এই মুহুর্তে, এই অপারেশনে মেটাডেটার মোটামুটি বিশৃঙ্খলাযুক্ত সংগ্রহ রয়েছে যা এক্সএলএ সংকলকটিতে এর সমকক্ষ অপারেশনের জৈব বিবর্তনকে প্রতিফলিত করে। ভবিষ্যতে, আমরা এই মেটাডেটা ( #741 ) একত্রিত করার পরিকল্পনা করছি।

ইনপুট

আউটপুট

উদাহরণ

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

ভাগ করা

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

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

• পূর্ণসংখ্যার জন্য: পূর্ণসংখ্যা বিভাগ যা কোনও ভগ্নাংশের অংশটি ফেলে দেওয়া বীজগণিতের ভাগফল উত্পাদন করে।
• ভাসমানের জন্য: আইইইই -754 থেকে division ।
• জটিল সংখ্যার জন্য: জটিল বিভাগ।
• কোয়ান্টাইজড ধরণের জন্য:
  • dequantize_op_quantize(divide, lhs, rhs, type(result)) ।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) 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]

আরো উদাহরণ

ডট_ জেনারাল

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

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

আরও আনুষ্ঠানিকভাবে, result[result_index] = dot_product , যেখানে:

• 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 যেখানে size(result_batching_index) = size(lhs_batching_dimensions) size(result_lhs_index) = size(lhs_result_dimensions) 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)) ।

কোয়ান্টাইজড প্রকারের জন্য, 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)) ।

হাইব্রিড কোয়ান্টাইজড প্রকারের জন্য, 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 এক্সিলারেটর ব্যাকেন্ডগুলিতে গণনার জন্য গতি এবং নির্ভুলতার মধ্যে ট্রেড অফকে নিয়ন্ত্রণ করে। এটি নিম্নলিখিতগুলির মধ্যে একটি হতে পারে (এই মুহুর্তে, এই এনাম মানগুলির শব্দার্থবিজ্ঞানগুলি আন্ডারস্পাইফাইড করা হয়েছে, তবে আমরা এটিকে #755 এ সম্বোধন করার পরিকল্পনা করছি):

• DEFAULT : দ্রুততম গণনা, তবে মূল সংখ্যায় কমপক্ষে সঠিক অনুমান।
• HIGH : ধীর গণনা, তবে মূল সংখ্যার আরও সঠিক অনুমান।
• HIGHEST : ধীরতম গণনা, তবে মূল সংখ্যার সর্বাধিক সঠিক অনুমান।

একটি DotAlgorithm ডট অপারেশন বাস্তবায়নের জন্য ব্যবহৃত অ্যালগরিদমের প্রধান বৈশিষ্ট্যগুলি সংজ্ঞায়িত করে, যা নির্ভুলতাও সংজ্ঞায়িত করে। যদি অ্যালগরিদম অ্যাট্রিবিউট ক্ষেত্রগুলি সেট করা থাকে তবে precision_config অবশ্যই DEFAULT হতে হবে। ডিফল্ট প্যারামিটারগুলি বাস্তবায়ন সংজ্ঞায়িত হওয়ায় DotAlgorithms কোনও ডিফল্ট মান নেই। এই হিসাবে, সমস্ত ডট অ্যালগরিদম ক্ষেত্রগুলি খালি ডট অ্যালগরিদম নির্দিষ্ট করার জন্য None সেট করা যেতে পারে, যা পরিবর্তে precision_config মানটি ব্যবহার করবে।

DotAlgorithm ক্ষেত্রগুলির মধ্যে রয়েছে:

• lhs_precision_type এবং rhs_precision_type , অপারেশনের LHS এবং RHS এর যথাযথতাগুলি গোলাকার হয়। যথার্থ প্রকারগুলি ইনপুটগুলির স্টোরেজ প্রকার এবং আউটপুট থেকে স্বতন্ত্র।
• জমা হওয়ার জন্য ব্যবহৃত নির্ভুলতা accumulation_type ।
• lhs_component_count , rhs_component_count এবং num_primitive_operations প্রয়োগ করা হয় যখন আমরা এমন একটি অ্যালগরিদম করছি যা এলএইচএস এবং/বা আরএইচএসকে একাধিক উপাদানগুলিতে পচে যায় এবং এই মানগুলিতে একাধিক "আদিম" ডট অপারেশন করে - সাধারণত একটি উচ্চতর নির্ভুলতা অনুকরণ করার জন্য (যেমন একটি উচ্চতর নির্ভুলতা অনুকরণ করে। জন্য উচ্চ-নির্ভুলতা গণনা : BF16_6X TF32_3X, ইত্যাদি)। কোনও পচে যাওয়া অ্যালগরিদমের জন্য, এই মানগুলি 1 এ সেট করা উচিত।
• কিছু পদক্ষেপের জন্য নিম্ন নির্ভুলতায় জমে থাকা অনুমোদিত কিনা তা নির্দিষ্ট করার জন্য allow_imprecise_accumulation (যেমন CUBLASLT_MATMUL_DESC_FAST_ACCUM )।

উদাহরণস্বরূপ DotAlgorithm বৈশিষ্ট্য:

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

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

কিছু সমর্থিত অ্যালগরিদম মানগুলির জন্য xla_data.proto > Algorithm দেখুন। টিকিট #2483 ব্যাকএন্ড দ্বারা সমর্থিত অ্যালগরিদমগুলিতে একটি কেন্দ্রীভূত ডক তৈরির পরিকল্পনাটি ক্যাপচার করে।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) size(lhs_batching_dimensions) = size(rhs_batching_dimensions) ।
• (সি 2) size(lhs_contracting_dimensions) = size(rhs_contracting_dimensions) ।
• (সি 3) is_unique(lhs_batching_dimensions + lhs_contracting_dimensions) ।
• (সি 4) is_unique(rhs_batching_dimensions + rhs_contracting_dimensions) ।
• (সি 5) 0 <= lhs_batching_dimensions < rank(lhs) ।
• (সি 6) 0 <= lhs_contracting_dimensions < rank(lhs) ।
• (সি 7) 0 <= rhs_batching_dimensions < rank(rhs) ।
• (সি 8) 0 <= rhs_contracting_dimensions < rank(rhs) ।
• (সি 9) dim(lhs, lhs_batching_dimensions...) = dim(rhs, rhs_batching_dimensions...) ।
• (সি 10) dim(lhs, lhs_contracting_dimensions...) = dim(rhs, rhs_contracting_dimensions...) ।
• (সি 11) size(precision_config) = 2 ।
• (সি 12) shape(result) = dim(lhs, lhs_batching_dimensions) + dim(lhs, lhs_result_dimensions) + dim(rhs, rhs_result_dimensions) ।
• যদি অপারেশনটি অ-কোয়ান্টাইজড টেনার ব্যবহার করে:
  • (সি 13) element_type(lhs) = element_type(rhs) ।
• যদি অপারেশনটি কোয়ান্টাইজড টেনার ব্যবহার করে:
  • (সি 14) is_quantized(lhs) = is_quantized(result) and is_quantized(rhs) ।
  • (সি 15) zero_points(rhs) = 0 ।
  • (সি 16) যদি is_per_axis_quantized(rhs) হয়, তবে quantization_dimension(rhs) rhs_contracting_dimensions নয়।
  • যদি is_quantized(lhs) :
  • (সি 17) storage_type(lhs) = storage_type(rhs) ।
  • (সি 18) expressed_type(lhs) = expressed_type(rhs) = expressed_type(result) ।
  • (C19) যদি is_per_tensor_quantized(rhs) , তবে is_per_tensor_quantized(result) ।
  • যদি !is_quantized(lhs) :
  • (সি 20) element_type(lhs) = expressed_type(rhs) = element_type(result) ।
• যদি !is_empty_algorithm(lhs_precision_type, rhs_precision_type, accumulation_type, lhs_component_count, rhs_component_count, num_primitive_operations allow_imprecise_accumulation) :
  • (সি 21) 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]]
//          ]

আরো উদাহরণ

ডায়নামিক_ব্রোডকাস্ট_ইন_ডিম

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

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

অপারেশনটি মাত্রাগুলির প্রসারিত আচরণ সম্পর্কে স্থির জ্ঞান প্রকাশ করার জন্য known_expanding_dimensions , known_nonexpanding_dimensions চ্ছিক বৈশিষ্ট্যগুলিও গ্রহণ করে। যদি নির্দিষ্ট না করা হয় তবে সমস্ত মাত্রা সম্ভবত প্রসারিত বলে ধরে নেওয়া হয়।

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (সি 1) element_type(result) দ্বারা দেওয়া হয়েছে:
  • element_type(operand) , যদি !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 .

ইনপুট

আউটপুট

সীমাবদ্ধতা

• (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]]]
//        ]
// %padding: [[1, 1],
//            [1, 1]]
%result = "stablehlo.dynamic_conv"(%lhs, %rhs, %padding) {
  window_strides = array<i64: 4, 4>,
  lhs_dilation = array<i64: 2, 2>,
  rhs_dilation = array<i64: 1, 1>,
  window_reversal = array<i1: false, false>,
  dimension_numbers = #stablehlo.conv<raw
    input_batch_dimension = 0,
    input_feature_dimension = 3,
    input_spatial_dimensions = [0, 1],
    kernel_input_feature_dimension = 2,
    kernel_output_feature_dimension = 3,
    kernel_spatial_dimensions = [0, 1],
    output_batch_dimension = 0,
    output_feature_dimension = 3,
    output_spatial_dimensions = [1, 2]
  >,
  feature_group_count = 1 : i64,
  batch_group_count = 1 : i64,
  precision_config = [#stablehlo<precision DEFAULT>, #stablehlo<precision DEFAULT>]
} : (tensor<1x4x4x1xi64>, tensor<3x3x1x1xi64>, tensor<2x2xi64>) -> tensor<1x2x2x1xi64>
// %result: [[
//            [[1], [5]],
//            [[10], [14]]
//          ]]